@pi-unipi/unipi 3.0.0-alpha.2 → 3.0.0-alpha.21

package/packages/input-shortcuts/src/burst.ts

@@ -0,0 +1,88 @@
+/**
+ * Typing-burst tracker for the undo history.
+ *
+ * The terminal-input handler must stay O(1): NO editor read per key except
+ * at burst start (which captures the pre-burst state, including programmatic
+ * changes like submit clearing the editor). Every input only stamps
+ * `lastInputAt`. One timer rides along: when it fires, an active burst that
+ * went quiet for BURST_IDLE_MS is flushed (post-burst state recorded) and
+ * closed; a burst that keeps going longer than BURST_MAX_MS is split so a
+ * long typing session still checkpoints. So a burst costs exactly two editor
+ * reads — one at open, one at close.
+ *
+ * Clock, timer and text access are injectable so tests can fake all of them.
+ */
+
+export const BURST_IDLE_MS = 600;
+export const BURST_MAX_MS = 2000;
+
+export interface BurstDeps {
+  /** Read the editor text (called only at burst open and close). */
+  getText(): string;
+  /** Where the captured states go (EditHistory.record). */
+  record(text: string): void;
+  now(): number;
+  setTimeout(handler: () => void, ms: number): unknown;
+  clearTimeout(handle: unknown): void;
+}
+
+export class BurstTracker {
+  private open = false;
+  private burstStart = 0;
+  private lastInputAt = 0;
+  private timer: unknown = null;
+
+  constructor(private readonly deps: BurstDeps) {}
+
+  /** A terminal input arrived — O(1), no editor read once a burst is open. */
+  onInput(): void {
+    const now = this.deps.now();
+    if (!this.open) {
+      this.open = true;
+      this.burstStart = now;
+      this.lastInputAt = now;
+      this.deps.record(this.deps.getText());
+      this.arm(now);
+      return;
+    }
+    this.lastInputAt = now;
+  }
+
+  /**
+   * Flush and close the burst if one is open: the post-burst text is
+   * recorded (a no-op when nothing changed). Undo/redo call this first so
+   * un-flushed typing is captured before stepping.
+   */
+  close(): void {
+    const wasOpen = this.open;
+    this.cancel();
+    if (wasOpen) {
+      this.deps.record(this.deps.getText());
+    }
+  }
+
+  /** Drop the timer and forget the burst WITHOUT recording anything. */
+  cancel(): void {
+    if (this.timer !== null) {
+      this.deps.clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.open = false;
+  }
+
+  private arm(now: number): void {
+    const idleRemainder = BURST_IDLE_MS - (now - this.lastInputAt);
+    const burstRemainder = BURST_MAX_MS - (now - this.burstStart);
+    const wait = Math.max(0, Math.min(idleRemainder, burstRemainder));
+    this.timer = this.deps.setTimeout(() => this.onTimer(), wait);
+  }
+
+  private onTimer(): void {
+    const now = this.deps.now();
+    if (this.open && now - this.lastInputAt < BURST_IDLE_MS && now - this.burstStart < BURST_MAX_MS) {
+      this.arm(now);
+      return;
+    }
+    this.close();
+  }
+}

package/packages/input-shortcuts/src/chord-overlay.ts

@@ -1,19 +1,19 @@
 /**
- * TUI overlay component for ALT+S chord mode.
+ * TUI overlay component for the ALT+S chord.
  *
- * Two states: root chord (action menu) and register sub-chord (register list).
- * Uses ctx.ui.custom() pattern from btw/compactor.
+ * One state: the root action menu. Uses the ctx.ui.custom() pattern from
+ * btw/compactor.
  *
  * IMPORTANT: The overlay ONLY captures the user's action selection.
  * Actions are NOT executed inside the overlay — they are deferred to the
- * caller via callbacks (onStash, onUndo, etc.). The caller closes the
+ * caller via callbacks (onStash, onUndo, …). The caller closes the
  * overlay via done(), then executes the action outside the overlay context
  * where ctx.ui.getEditorText() / setEditorText() actually work.
  *
- * Closes on ESC or after selecting an action. No timeout.
+ * Closes on ESC or after selecting an action; an unknown key closes silently.
+ * No timeout.
  */
 
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
   Container,
   Key,
@@ -23,8 +23,6 @@ import {
   type TUI,
   type KeybindingsManager,
 } from "@earendil-works/pi-tui";
-import type { ChordState } from "./types.ts";
-import { THINKING_CYCLE } from "./types.ts";
 
 /** Theme-like interface matching pi-coding-agent's Theme */
 interface ThemeLike {
@@ -39,11 +37,9 @@ export interface ChordCallbacks {
   onStash: () => void;
   onUndo: () => void;
   onRedo: () => void;
-  onAppendRegister: (index: number) => void;
   onAppendStash: () => void;
-  onCopy: () => void;
-  onCut: () => void;
-  onToggleThinking: () => void;
+  onCopyLastResponse: () => void | Promise<void>;
+  onKanboard: () => void | Promise<void>;
 }
 
 // ─── Action menu lines ──────────────────────────────────────────────────────
@@ -52,26 +48,15 @@ const ROOT_ACTIONS: Array<{ key: string; label: string }> = [
   { key: "S", label: "Stash / Restore" },
   { key: "U", label: "Undo" },
   { key: "R", label: "Redo" },
-  { key: "A", label: "Append from register" },
-  { key: "Y", label: "Copy to clipboard" },
-  { key: "D", label: "Cut to clipboard" },
-  { key: "T", label: "Toggle thinking" },
+  { key: "A", label: "Append stash" },
+  { key: "Y", label: "Copy last response" },
+  { key: "K", label: "Add to kanboard backlog" },
 ];
 
-function buildRegisterActions(): Array<{ key: string; label: string }> {
-  const actions: Array<{ key: string; label: string }> = [];
-  for (let i = 0; i <= 9; i++) {
-    actions.push({ key: String(i), label: `Register ${i}` });
-  }
-  actions.push({ key: "S", label: "Stash register" });
-  return actions;
-}
-
-// ─── ChordOverlay Component ─────────────────────────────────────────────────
+// ─── ChordOverlay Component ─────────────────────────────────────────────────────────
 
 export class ChordOverlay extends Container implements Focusable {
   private _focused = true;
-  private state: ChordState = "chord_root";
   private actionLines: Text[] = [];
   private tui: TUI;
   private theme: ThemeLike;
@@ -103,22 +88,12 @@ export class ChordOverlay extends Container implements Focusable {
   }
 
   private renderRootMenu(): void {
-    this.state = "chord_root";
     this.actionLines = ROOT_ACTIONS.map(
       (a) => new Text(`  ${this.theme.fg("accent", `[${a.key}]`)} ${a.label}`, 1, 0),
     );
     this.requestRender();
   }
 
-  private renderRegisterMenu(): void {
-    this.state = "chord_reg";
-    const regActions = buildRegisterActions();
-    this.actionLines = regActions.map(
-      (a) => new Text(`  ${this.theme.fg("accent", `[${a.key}]`)} ${a.label}`, 1, 0),
-    );
-    this.requestRender();
-  }
-
   private requestRender(): void {
     this.tui.requestRender();
   }
@@ -129,13 +104,7 @@ export class ChordOverlay extends Container implements Focusable {
       return;
     }
 
-    const key = data.toLowerCase();
-
-    if (this.state === "chord_root") {
-      this.handleRootKey(key);
-    } else if (this.state === "chord_reg") {
-      this.handleRegKey(key);
-    }
+    this.handleRootKey(data.toLowerCase());
   }
 
   private handleRootKey(key: string): void {
@@ -150,16 +119,13 @@ export class ChordOverlay extends Container implements Focusable {
         this.closeThenExecute(() => this.callbacks.onRedo());
         break;
       case "a":
-        this.enterRegChord();
-        return; // don't close — show register sub-menu
-      case "y":
-        this.closeThenExecute(() => this.callbacks.onCopy());
+        this.closeThenExecute(() => this.callbacks.onAppendStash());
         break;
-      case "d":
-        this.closeThenExecute(() => this.callbacks.onCut());
+      case "y":
+        this.closeThenExecute(() => this.callbacks.onCopyLastResponse());
         break;
-      case "t":
-        this.closeThenExecute(() => this.callbacks.onToggleThinking());
+      case "k":
+        this.closeThenExecute(() => this.callbacks.onKanboard());
         break;
       default:
         // Unknown key — silent close
@@ -168,28 +134,12 @@ export class ChordOverlay extends Container implements Focusable {
     }
   }
 
-  private handleRegKey(key: string): void {
-    if (key === "s") {
-      this.closeThenExecute(() => this.callbacks.onAppendStash());
-    } else if (/^[0-9]$/.test(key)) {
-      const index = parseInt(key, 10);
-      this.closeThenExecute(() => this.callbacks.onAppendRegister(index));
-    } else {
-      // Unknown key — silent close
-      this.close();
-    }
-  }
-
-  private enterRegChord(): void {
-    this.renderRegisterMenu();
-  }
-
   /**
    * Close the overlay, then execute the action.
    * The action runs AFTER the overlay is dismissed, so ctx.ui.getEditorText()
    * and setEditorText() work correctly (they don't work while overlay is open).
    */
-  private closeThenExecute(action: () => void): void {
+  private closeThenExecute(action: () => void | Promise<void>): void {
     this.done(); // close the overlay
     // Use setTimeout(0) to defer action to next tick — overlay will be dismissed by then
     setTimeout(action, 0);
@@ -213,7 +163,7 @@ export class ChordOverlay extends Container implements Focusable {
     lines.push(this.theme.fg("borderMuted", `┌${"─".repeat(innerWidth)}┐`));
 
     // Title
-    const title = this.state === "chord_root" ? "Input Shortcuts" : "Append from register";
+    const title = "Input Shortcuts";
     const titlePadded = title.padEnd(innerWidth);
     lines.push(`${this.theme.fg("borderMuted", "│")}${this.theme.fg("accent", titlePadded)}${this.theme.fg("borderMuted", "│")}`);
 

package/packages/input-shortcuts/src/cleared-input.ts

@@ -0,0 +1,97 @@
+/**
+ * Ctrl+C keeps what it cleared (Devin-style):
+ *   - the text stays in the transcript, struck through (UI-only entry — custom
+ *     entries never reach the model, so no tokens and no prefix-cache churn);
+ *   - it is pushed onto the editor's ↑ history, so ↑ brings it back.
+ *
+ * pi still does the clearing (and double Ctrl+C still exits). We only look at
+ * the key first via onTerminalInput and never consume it.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { matchesKey, truncateToWidth, type Component, type TUI } from "@earendil-works/pi-tui";
+import type { KitTheme } from "@pi-unipi/core";
+
+export const CLEARED_ENTRY = "unipi-cleared-input";
+const PROBE_WIDGET = "unipi-cleared-input-probe";
+const MAX_LINES = 3;
+
+interface EditorLike {
+  getText(): string;
+  addToHistory(text: string): void;
+}
+
+function isEditor(c: unknown): c is EditorLike {
+  const e = c as Partial<EditorLike> | null | undefined;
+  return typeof e?.getText === "function" && typeof e.addToHistory === "function";
+}
+
+const strike = (s: string) => `\x1b[9m${s}\x1b[29m`;
+
+/** `⌫ ~~fix the flaky test~~  ↑ restores` (+ up to two more struck lines). */
+export function clearedLines(t: KitTheme, text: string, width: number): string[] {
+  const all = text.replace(/\s+$/u, "").split("\n");
+  const shown = all.slice(0, MAX_LINES);
+  const out = shown.map((l, i) => truncateToWidth(`${i === 0 ? t.fg("dim", "⌫ ") : "  "}${t.fg("dim", strike(l))}`, width));
+  if (all.length > shown.length) out.push(t.fg("dim", `  … ${String(all.length - shown.length)} more line${all.length - shown.length === 1 ? "" : "s"}`));
+  out[0] = truncateToWidth(`${out[0]!}${t.fg("dim", "  ↑ restores")}`, width);
+  return out;
+}
+
+/**
+ * Decide what to record for a key press. Returns the text to keep, or
+ * undefined when the key isn't Ctrl+C / the focus isn't a non-empty editor.
+ */
+export function clearedText(data: string, focused: unknown): string | undefined {
+  if (!matchesKey(data, "ctrl+c") || !isEditor(focused)) return undefined;
+  const text = focused.getText();
+  return text.trim() ? text : undefined;
+}
+
+export function installClearedInput(pi: ExtensionAPI): void {
+  let tui: TUI | undefined;
+  let unsub: (() => void) | undefined;
+
+  try {
+    pi.registerEntryRenderer<{ text: string }>(CLEARED_ENTRY, (entry, _opts, theme): Component | undefined => {
+      const text = entry.data?.text;
+      if (!text) return undefined;
+      return { invalidate() {}, render: (w: number) => clearedLines(theme as KitTheme, text, w) };
+    });
+  } catch {
+    /* UI-dependent */
+  }
+
+  pi.on("session_start", (_e, ctx: ExtensionContext) => {
+    unsub?.();
+    unsub = undefined;
+    if (!ctx.hasUI) return;
+    try {
+      // An empty widget, only to get hold of the TUI (for the focused editor).
+      ctx.ui.setWidget(PROBE_WIDGET, (t) => {
+        tui = t;
+        return { invalidate() {}, render: () => [] };
+      }, { placement: "belowEditor" });
+      unsub = ctx.ui.onTerminalInput((data) => {
+        try {
+          const focused = (tui as { getFocusedComponent?: () => unknown } | undefined)?.getFocusedComponent?.();
+          const text = clearedText(data, focused);
+          if (text === undefined) return undefined;
+          (focused as EditorLike).addToHistory(text);
+          pi.appendEntry(CLEARED_ENTRY, { text });
+        } catch {
+          /* never block the key */
+        }
+        return undefined;
+      });
+    } catch {
+      /* UI-dependent */
+    }
+  });
+
+  pi.on("session_shutdown", () => {
+    unsub?.();
+    unsub = undefined;
+    tui = undefined;
+  });
+}