P2-10: Auto-close brackets and quotes

[hybridmachine]

Description

Automatically insert closing brackets and quotes when typing an opener.

Implementation

• In SCN_CHARADDED, detect opening characters: (, [, {, ", ', `
• Insert corresponding closing character after cursor
• If text is selected, wrap selection with pair
• Skip-over: if typing closing char and it's already there, just move cursor
• Backspace on empty pair deletes both characters
• Language-aware: disable quote pairing inside strings/comments
• Preference toggle: "Auto-close brackets"

Key Files

• macos/platform/main_phase7.mm
• macos/platform/settings_manager.h

[hybridmachine]

Sprint plan: #38 Auto-close brackets and quotes

Goal

Improve typing flow by automatically pairing delimiters, with safe behavior around selections and existing closing chars.

Implementation breakdown

1. Add settings surface.

• Add preference toggle Auto-close brackets (default aligned with product decision; if unspecified, default on for modern editor behavior).
• Persist setting via existing settings manager flow.

2. Pair insertion on opener.

• In SCN_CHARADDED, detect opener chars: ( [ { " ' `.
• Insert matching closer and place caret between pair.
• Ensure this is a single undo step (grouped action).

3. Wrap selection behavior.

• If non-empty selection exists when opener typed, wrap selection with opener/closer.
• Preserve selection/caret semantics consistent with existing editor behavior.

4. Skip-over behavior.

• If user types a closer char and next char already matches, move caret forward instead of inserting duplicate closer.

5. Pair-aware backspace.

• When caret is between an auto-inserted empty pair, backspace removes both chars.
• Avoid aggressive deletion when pair was not auto-generated or context does not match.

6. Context sensitivity.

• Avoid quote auto-pairing inside comments/strings using lexer/style checks already available from Scintilla state.
• Bracket pairing may remain active in code contexts where appropriate.

7. Robustness and compatibility.

• Respect overwrite/rectangular selection modes if relevant.
• Avoid conflicts with existing auto-indent/newline handlers.

Validation

• Manual checks:
  • Openers auto-insert matching closer.
  • Selection wrapping works for single/multi-line text.
  • Typing closer over existing closer skips forward.
  • Backspace on empty pair removes both.
  • Disabling preference turns feature off immediately.
  • Quote pairing suppressed in string/comment contexts.
• Regression checks:
  • Undo/redo granularity remains intuitive.
  • No duplicate char insertion under fast typing.

Key files

• macos/platform/main_phase7.mm
• macos/platform/settings_manager.h

[hybridmachine]

Plan Review

Overall Assessment

Well-structured plan covering the essential behaviors (pair insertion, wrap selection, skip-over, pair-aware backspace, context sensitivity). Needs more detail on a few implementation mechanisms.

Critical Issues

1. Key file reference is partially incorrect
main_phase7.mm does not exist in the codebase. The relevant files are:

• macos/platform/app_delegate.mm — main view SCN_CHARADDED handler (line ~299)
• macos/platform/split_view.mm — secondary view SCN_CHARADDED handler (line ~163)
• macos/platform/settings_manager.h — AppSettings struct (correct reference)
• New: macos/platform/auto_close.h/mm (following codebase module pattern)

2. SCN_CHARADDED ordering with auto-indent
Both this feature and auto-indent trigger on SCN_CHARADDED. Currently performAutoIndent() is called in both app_delegate.mm and split_view.mm when ctx().autoIndent is true. The plan should specify:

• Execution order: Does auto-close run before or after auto-indent?
• Interaction on newline: When Enter is pressed inside {|}, auto-close backspace tracking + auto-indent both apply. These need to be coordinated.
• Recommendation: Auto-close should run first (insert closing char), then auto-indent adjusts indentation. The auto-close handler should return a flag indicating whether it consumed the character.

3. Backspace handling mechanism is underspecified
"Pair-aware backspace" is non-trivial because SCN_CHARADDED does not fire on backspace. The plan needs to specify the mechanism:

• Option A: Handle in SCN_KEY notification (if available in Cocoa Scintilla)
• Option B: Intercept via SCN_MODIFIED with SC_MOD_DELETETEXT flag
• Option C: Use Cocoa key event interception before Scintilla processes it
• This needs investigation — it's the riskiest part of the implementation.

Design Clarifications Needed

4. Split view support
Both Scintilla views handle SCN_CHARADDED independently. The auto-close module needs to work correctly regardless of which view fires the notification. The handler function should accept the view pointer as a parameter (consistent with performAutoIndent(ctx().scintillaView, ...) pattern).

5. Tracking auto-inserted pairs
Skip-over and pair-aware backspace both require knowing whether a closing character was auto-inserted vs. manually typed. The plan should specify how this state is tracked:

• A simple approach: check if the character after the caret matches the expected closer (no explicit tracking needed for skip-over)
• For backspace: check if caret is between a matched pair and both chars were inserted in the same undo group

6. Settings field
Needs bool autoCloseBrackets added to AppSettings in settings_manager.h with a default value (suggest true).

7. Context sensitivity detail
"Using lexer/style checks already available from Scintilla state" — this would use SCI_GETSTYLEAT to check the lexer style at the caret position. Worth being explicit: styles like SCE_C_STRING, SCE_C_CHARACTER, SCE_C_COMMENT, etc. indicate contexts where quote pairing should be suppressed.

Minor Notes

• Undo grouping should use SCI_BEGINUNDOACTION / SCI_ENDUNDOACTION — worth stating explicitly.
• The codebase pattern is to create a dedicated module (auto_close.h/mm) with a function like performAutoClose(void* scintillaView, int ch).
• Validation checklist is comprehensive.
• Size/M seems appropriate.

[hybridmachine]

Sprint plan amendment (addressing review)

Thanks — this updates the plan with concrete notification ordering and backspace handling design.

Final implementation shape

1. New module (required by repo pattern)

• Add macos/platform/auto_close.h + macos/platform/auto_close.mm
• Add module to macos/CMakeLists.txt
• API:
  • void handleAutoCloseCharAdded(void* sci, int ch, int languageIndex);
  • void handleAutoCloseModified(void* sci, const SciNotification* scn, int languageIndex);

2. Correct integration points

• app_delegate.mm and split_view.mm:
  • In SCN_CHARADDED: call auto-close handler first, then auto-indent handler
  • In SCN_MODIFIED: call auto-close modified handler for delete/backspace logic

3. Settings and persistence

• settings_manager.h: add bool autoCloseBrackets = true;
• settings_manager.mm: load/save autoCloseBrackets
• app_state.h: add runtime flag if needed for fast checks
• app_delegate.mm: load and save with existing settings flow

4. Behavior details

• Openers (( [ { " ' `): insert matching closer and place caret between pair
• Selection wrapping: if selection exists, wrap selection in pair within one undo action
• Skip-over: when typing closer and next char already matches, move caret instead of inserting

5. Backspace mechanism (explicit)

• Use SCN_MODIFIED with delete-type flags (add missing constants to npp_constants.h from Scintilla headers as needed).
• When deletion is backspace at a caret between matching pair chars, delete paired closer too.
• Do not over-delete when selection is non-empty or pair context is not exact.

6. Context sensitivity

• Use SCI_GETSTYLEAT to suppress quote pairing in string/comment styles where appropriate.
• Bracket pairing remains active for code contexts.

7. Undo granularity

• Pair insert/wrap operations grouped with SCI_BEGINUNDOACTION / SCI_ENDUNDOACTION.

Validation checklist

• Pair insertion, wrap selection, skip-over all work in both views
• Backspace removes empty auto-pair in both views
• Auto-close and auto-indent coexist (newline behavior unchanged)
• Setting toggle persists and takes effect immediately
• No duplicate insertion under rapid typing