pi-double-esc 1.0.11 → 1.0.12

package/README.md

@@ -78,15 +78,16 @@ PI_DOUBLE_ESC_MS=2000 pi
 
 ## How It Works
 
-The extension replaces pi's editor component with a `CustomEditor` subclass that intercepts Escape key presses:
+The extension decorates pi's current editor instead of replacing it:
 
-1. On each `session_start`, `ctx.ui.setEditorComponent()` installs the custom editor
-2. The editor uses `ctx.isIdle()` (which reflects `!session.isStreaming`) to detect streaming state
-3. While streaming, the first Escape shows a visual hint and starts a debounce timer
-4. A second Escape within the window calls `super.handleInput(data)` to perform the actual abort
-5. Any other keypress or timeout expiry dismisses the hint
+1. On each `session_start`, it reads the current editor factory with `ctx.ui.getEditorComponent()`.
+2. It creates that editor, or a `CustomEditor` when no extension installed one earlier.
+3. It decorates the editor's input and render methods with double-Escape behavior.
+4. While streaming, the first Escape shows a visual hint and starts a debounce timer.
+5. A second Escape within the window passes Escape to the current editor, which aborts the response.
+6. Any other keypress or timeout expiry dismisses the hint.
 
-The debounce logic lives in `src/double-esc-logic.ts` as pure functions for testability.
+This design preserves behavior from editor extensions loaded before `pi-double-esc`. The debounce logic lives in `src/double-esc-logic.ts` as pure functions for testability.
 
 ## Development
 

package/double-esc.ts

@@ -11,14 +11,26 @@
  * When not streaming:
  *   - Escape works normally (immediate) — no debounce applied
  *
- * Autocomplete dismissal always works on single Escape (handled by Editor parent).
+ * Autocomplete dismissal always works on single Escape (handled by the current editor).
+ * The extension decorates an editor installed earlier instead of replacing it.
  *
  * The debounce timeout defaults to 1500ms and can be configured via
  * the PI_DOUBLE_ESC_MS environment variable.
  */
 
-import { CustomEditor, type ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
-import { matchesKey, truncateToWidth, visibleWidth, type TUI, type EditorTheme } from "@earendil-works/pi-tui";
+import {
+  CustomEditor,
+  type ExtensionAPI,
+  type ExtensionContext,
+  type Theme,
+} from "@earendil-works/pi-coding-agent";
+import {
+  matchesKey,
+  truncateToWidth,
+  visibleWidth,
+  type EditorComponent,
+  type TUI,
+} from "@earendil-works/pi-tui";
 import {
   createInitialState,
   getDefaultDebounceMs,
@@ -28,93 +40,95 @@ import {
   type DoubleEscapeState,
 } from "./src/index.js";
 
-class DoubleEscapeEditor extends CustomEditor {
-  private escState: DoubleEscapeState = createInitialState();
-  private debounceTimer: ReturnType<typeof setTimeout> | null = null;
-  private isIdle: () => boolean;
-  private appTheme: Theme;
-
-  constructor(
-    tui: TUI,
-    editorTheme: EditorTheme,
-    keybindings: any,
-    theme: Theme,
-    isIdle: () => boolean,
-    options?: any,
-  ) {
-    super(tui, editorTheme, keybindings, options);
-    this.appTheme = theme;
-    this.isIdle = isIdle;
-  }
-
-  private clearDebounce(): void {
-    if (this.debounceTimer) {
-      clearTimeout(this.debounceTimer);
-      this.debounceTimer = null;
-    }
-  }
+/** Add double-Escape behavior without replacing the current editor instance. */
+function decorateDoubleEscapeEditor(
+  editor: EditorComponent,
+  tui: TUI,
+  appTheme: Theme,
+  isIdle: () => boolean,
+): EditorComponent {
+  let escapeState: DoubleEscapeState = createInitialState();
+  let debounceTimer: ReturnType<typeof setTimeout> | undefined;
 
-  handleInput(data: string): void {
-    if (matchesKey(data, "escape")) {
-      const result = handleEscape(this.escState, this.isIdle());
+  const clearDebounce = (): void => {
+    clearTimeout(debounceTimer);
+    debounceTimer = undefined;
+  };
 
-      this.escState = result.state;
-
-      if (result.action === "show_hint") {
-        this.clearDebounce();
-        this.debounceTimer = setTimeout(() => {
-          this.escState = handleTimeout(this.escState).state;
-          this.tui.requestRender();
-        }, getDefaultDebounceMs());
-        this.tui.requestRender();
-        return;
-      }
-
-      if (result.action === "abort") {
-        this.clearDebounce();
-        super.handleInput(data);
-        return;
+  const handleInput = editor.handleInput.bind(editor);
+  editor.handleInput = (data: string): void => {
+    if (!matchesKey(data, "escape")) {
+      if (escapeState.hintActive) {
+        escapeState = handleOtherKey(escapeState).state;
+        clearDebounce();
+        tui.requestRender();
       }
-
-      // "nothing" — idle state, pass through
-      super.handleInput(data);
+      handleInput(data);
       return;
     }
 
-    // Non-escape key while hint is showing: dismiss hint
-    if (this.escState.hintActive) {
-      this.escState = handleOtherKey(this.escState).state;
-      this.clearDebounce();
-      this.tui.requestRender();
+    const result = handleEscape(escapeState, isIdle());
+    escapeState = result.state;
+
+    if (result.action === "show_hint") {
+      clearDebounce();
+      debounceTimer = setTimeout(() => {
+        escapeState = handleTimeout(escapeState).state;
+        tui.requestRender();
+      }, getDefaultDebounceMs());
+      tui.requestRender();
+      return;
     }
 
-    super.handleInput(data);
-  }
+    clearDebounce();
+    handleInput(data);
+  };
 
-  render(width: number): string[] {
-    const lines = super.render(width);
-    if (lines.length === 0) return lines;
+  const render = editor.render.bind(editor);
+  editor.render = (width: number): string[] => {
+    const lines = render(width);
+    if (!escapeState.hintActive || lines.length === 0) return lines;
 
-    if (this.escState.hintActive) {
-      const label = " esc again to abort ";
-      const styledLabel = this.appTheme.fg("dim", label);
-      const last = lines.length - 1;
-      const line = lines[last]!;
-      const lineW = visibleWidth(line);
-      const gap = 2;
-      if (lineW >= label.length + gap) {
-        lines[last] = truncateToWidth(line, lineW - label.length - gap, "") + styledLabel + truncateToWidth(line, gap, "");
-      }
+    const label = " esc again to abort ";
+    const styledLabel = appTheme.fg("dim", label);
+    const last = lines.length - 1;
+    const line = lines[last]!;
+    const lineWidth = visibleWidth(line);
+    const gap = 2;
+    if (lineWidth >= label.length + gap) {
+      lines[last] =
+        truncateToWidth(line, lineWidth - label.length - gap, "") +
+        styledLabel +
+        truncateToWidth(line, gap, "");
     }
-
     return lines;
-  }
+  };
+
+  return editor;
 }
 
+// Marks the factory this extension installs. Repeated session_start events
+// (reload, new session, resume) must reuse it instead of stacking a second
+// decorator: the outer copy would swallow the first Escape and the inner one
+// would then show the hint again instead of aborting.
+const DECORATED_FACTORY = Symbol("pi-double-esc.decoratedFactory");
+
+type EditorFactory = NonNullable<ReturnType<ExtensionContext["ui"]["getEditorComponent"]>>;
+type DecoratedEditorFactory = EditorFactory & { [DECORATED_FACTORY]?: true };
+
 export default function (pi: ExtensionAPI) {
   pi.on("session_start", (_event, ctx) => {
-    ctx.ui.setEditorComponent((tui, editorTheme, kb) =>
-      new DoubleEscapeEditor(tui, editorTheme, kb, ctx.ui.theme, () => ctx.isIdle()),
-    );
+    const previousEditorFactory = ctx.ui.getEditorComponent() as DecoratedEditorFactory | undefined;
+    if (previousEditorFactory?.[DECORATED_FACTORY]) return;
+
+    const editorFactory: DecoratedEditorFactory = (tui, editorTheme, keybindings) => {
+      const editor =
+        previousEditorFactory?.(tui, editorTheme, keybindings) ??
+        new CustomEditor(tui, editorTheme, keybindings);
+      return decorateDoubleEscapeEditor(editor, tui, ctx.ui.theme, () => ctx.isIdle());
+    };
+    editorFactory[DECORATED_FACTORY] = true;
+
+    ctx.ui.setEditorComponent(editorFactory);
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-double-esc",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "description": "Prevent accidental Escape from aborting the LLM — requires double-press to interrupt while streaming",
   "type": "module",
   "author": "Tom X Nguyen",