@mrclrchtr/supi-extras 0.1.0

package/src/prompt-stash.ts

@@ -0,0 +1,321 @@
+/**
+ * Prompt stash extension for pi.
+ *
+ * Provides `Alt+S` to stash the current editor text and `/supi-stash` for
+ * browsing and managing stashed drafts with a keyboard-driven overlay picker.
+ *
+ * Stashes are persisted to ~/.pi/agent/supi/prompt-stash.json so they survive
+ * pi restarts. On I/O errors the stash falls back to in-memory-only operation.
+ */
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { DynamicBorder } from "@earendil-works/pi-coding-agent";
+import { Container, type SelectItem, SelectList, Spacer, Text } from "@earendil-works/pi-tui";
+import { copyToClipboard } from "./clipboard.ts";
+
+/** In-memory stash entry. */
+interface Stash {
+  id: string;
+  name: string;
+  text: string;
+  createdAt: number;
+}
+
+/** Storage directory relative to the user's home directory. */
+const STORAGE_RELATIVE_DIR = ".pi/agent/supi";
+const STASH_FILE = "prompt-stash.json";
+
+/** Resolve the absolute path to the stash persistence file. */
+function getStashFilePath(): string {
+  return join(homedir(), STORAGE_RELATIVE_DIR, STASH_FILE);
+}
+
+/** Attempt to parse stashes from a raw JSON value. Returns null on failure. */
+function parseStashEntries(raw: unknown): Map<string, Stash> | null {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const map = new Map<string, Stash>();
+  for (const [id, entry] of Object.entries(raw)) {
+    if (entry && typeof entry === "object") {
+      map.set(id, entry as Stash);
+    }
+  }
+  return map.size > 0 ? map : null;
+}
+
+/**
+ * Load stashes from disk. Returns an empty map when the file does not exist
+ * or cannot be parsed — the stash degrades gracefully to in-memory-only.
+ */
+function loadStashesFromDisk(): Map<string, Stash> {
+  let content: string;
+  try {
+    content = readFileSync(getStashFilePath(), "utf-8");
+  } catch (err) {
+    // ENOENT on first run is expected — warn on all other errors
+    if ((err as NodeJS.ErrnoException)?.code !== "ENOENT") {
+      // biome-ignore lint/suspicious/noConsole: deliberate degradation warning
+      console.warn("[supi-extras] Failed to load prompt stash from disk, starting fresh:", err);
+    }
+    return new Map();
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(content);
+  } catch (err) {
+    // biome-ignore lint/suspicious/noConsole: deliberate degradation warning
+    console.warn("[supi-extras] Failed to parse prompt stash file, starting fresh:", err);
+    return new Map();
+  }
+
+  const root =
+    parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : null;
+  if (!root) return new Map();
+
+  return parseStashEntries(root.stashes) ?? new Map();
+}
+
+/**
+ * Save stashes to disk. Silently ignores write errors so a read-only
+ * filesystem never breaks the stash in-memory.
+ */
+function saveStashesToDisk(stashes: Map<string, Stash>): void {
+  try {
+    const filePath = getStashFilePath();
+    mkdirSync(dirname(filePath), { recursive: true });
+
+    const data: Record<string, Stash> = {};
+    for (const [id, stash] of stashes) {
+      data[id] = stash;
+    }
+
+    writeFileSync(filePath, `${JSON.stringify({ stashes: data }, null, 2)}\n`, "utf-8");
+  } catch (err) {
+    // biome-ignore lint/suspicious/noConsole: deliberate degradation warning
+    console.warn(
+      "[supi-extras] Failed to persist prompt stash to disk, continuing in-memory:",
+      err,
+    );
+  }
+}
+
+/** Persisted stash store. Loaded from disk at module init. */
+const STASHES = loadStashesFromDisk();
+
+/** Reset stashes — intended for tests only. Also clears the persisted file. */
+export function _resetStashes(): void {
+  STASHES.clear();
+  saveStashesToDisk(STASHES);
+}
+
+/** Generate a unique stash id. */
+function generateId(): string {
+  return `stash-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+}
+
+/**
+ * Derive a default name from the first line of the prompt text.
+ * Falls back to "Untitled" for empty input.
+ */
+function generateName(text: string): string {
+  const firstLine = text.split("\n")[0]?.trim() ?? "";
+  if (firstLine.length > 0 && firstLine.length <= 40) return firstLine;
+  if (firstLine.length > 40) return `${firstLine.slice(0, 37)}...`;
+  return "Untitled";
+}
+
+/** Result returned from the stash picker overlay. */
+type StashPickerResult =
+  | { action: "restore" | "copy"; stash: Stash }
+  | { action: "cleared" }
+  | null;
+
+/**
+ * Build the custom overlay component for the stash picker.
+ *
+ * Returns a promise that resolves when the user picks an action
+ * (restore, copy, clear-all) or cancels (null).
+ *
+ * The overlay stays open on single-delete (`d`) and refreshes the list
+ * in-place. Close actions: Enter (restore), `c` (copy), `D` (clear-all),
+ * Escape (cancel).
+ */
+function showStashPickerOverlay(ctx: ExtensionContext): Promise<StashPickerResult> {
+  return ctx.ui.custom<StashPickerResult>(
+    (tui, theme, _kb, done) => {
+      const container = new Container();
+      let selectList: SelectList;
+
+      function buildItems(): SelectItem[] {
+        return Array.from(STASHES.values())
+          .sort((a, b) => b.createdAt - a.createdAt)
+          .map((s) => ({ value: s.id, label: s.name }));
+      }
+
+      function createSelectList(items: SelectItem[], selectedIndex?: number): SelectList {
+        const list = new SelectList(items, Math.min(items.length, 10), {
+          selectedPrefix: (text: string) => theme.fg("accent", text),
+          selectedText: (text: string) => theme.fg("accent", text),
+          description: (text: string) => theme.fg("muted", text),
+          scrollInfo: (text: string) => theme.fg("dim", text),
+          noMatch: (text: string) => theme.fg("warning", text),
+        });
+
+        list.onSelect = (item) => {
+          const stash = STASHES.get(item.value);
+          if (stash) done({ action: "restore", stash });
+        };
+        list.onCancel = () => done(null);
+
+        if (selectedIndex !== undefined) {
+          list.setSelectedIndex(selectedIndex);
+        }
+        return list;
+      }
+
+      function refresh(preferredIndex?: number) {
+        const items = buildItems();
+        if (items.length === 0) {
+          done(null);
+          return;
+        }
+
+        container.clear();
+        container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+        container.addChild(new Text(theme.fg("accent", theme.bold("  Stashed Prompts"))));
+        container.addChild(new Spacer(1));
+
+        selectList = createSelectList(items, preferredIndex);
+        container.addChild(selectList);
+
+        container.addChild(new Spacer(1));
+        container.addChild(
+          new Text(theme.fg("dim", "  c:copy  d:delete  D:clear-all  enter:restore  esc:cancel")),
+        );
+        container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+
+        tui.requestRender();
+      }
+
+      // Initial build
+      refresh();
+
+      return {
+        render(width: number) {
+          return container.render(width);
+        },
+        invalidate() {
+          container.invalidate();
+        },
+        handleInput(data: string) {
+          const item = selectList.getSelectedItem();
+          if (!item) {
+            selectList.handleInput(data);
+            tui.requestRender();
+            return;
+          }
+
+          const stash = STASHES.get(item.value);
+          if (!stash) {
+            selectList.handleInput(data);
+            tui.requestRender();
+            return;
+          }
+
+          if (data === "c") {
+            done({ action: "copy", stash });
+            return;
+          }
+
+          if (data === "d") {
+            const currentItems = buildItems();
+            const oldIndex = currentItems.findIndex((i) => i.value === item.value);
+            STASHES.delete(stash.id);
+            saveStashesToDisk(STASHES);
+            refresh(oldIndex);
+            return;
+          }
+
+          if (data === "D") {
+            STASHES.clear();
+            saveStashesToDisk(STASHES);
+            done({ action: "cleared" });
+            return;
+          }
+
+          selectList.handleInput(data);
+          tui.requestRender();
+        },
+      };
+    },
+    { overlay: true },
+  );
+}
+
+/** Register the prompt-stash shortcuts and commands. */
+export default function promptStash(pi: ExtensionAPI) {
+  pi.registerShortcut("alt+s", {
+    description: "Stash current editor text",
+    handler: async (ctx) => {
+      const text = ctx.ui.getEditorText();
+      if (!text.trim()) {
+        ctx.ui.notify("Editor is empty — nothing to stash", "warning");
+        return;
+      }
+
+      const defaultName = generateName(text);
+      const name = await ctx.ui.input("Stash name:", defaultName);
+      if (name === undefined) return;
+
+      const id = generateId();
+      STASHES.set(id, {
+        id,
+        name: name || defaultName,
+        text,
+        createdAt: Date.now(),
+      });
+      saveStashesToDisk(STASHES);
+      ctx.ui.setEditorText("");
+      ctx.ui.notify(`Stashed: "${name || defaultName}"`, "info");
+    },
+  });
+
+  pi.registerCommand("supi-stash", {
+    description: "Browse, restore, copy, delete, or clear all stashed prompts",
+    handler: async (_args, ctx) => {
+      if (STASHES.size === 0) {
+        ctx.ui.notify("No stashed prompts", "info");
+        return;
+      }
+
+      const result = await showStashPickerOverlay(ctx);
+      if (!result) return;
+
+      if (result.action === "cleared") {
+        ctx.ui.notify("All stashes cleared", "info");
+        return;
+      }
+
+      if (result.action === "restore") {
+        ctx.ui.setEditorText(result.stash.text);
+        ctx.ui.notify(`Restored: "${result.stash.name}"`, "info");
+        return;
+      }
+
+      // copy
+      const ok = await copyToClipboard(result.stash.text, ctx.cwd, pi);
+      ctx.ui.notify(
+        ok ? `Copied "${result.stash.name}" to clipboard` : "Failed to copy to clipboard",
+        ok ? "info" : "error",
+      );
+    },
+  });
+
+  pi.on("session_shutdown", () => {
+    saveStashesToDisk(STASHES);
+  });
+}

package/src/skill-shortcut.ts

@@ -0,0 +1,122 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { fuzzyFilter } from "@earendil-works/pi-tui";
+
+/**
+ * Extension: `$` as a shortcut prefix for skills.
+ *
+ * - `$agent-browser` expands to `/skill:agent-browser`
+ * - Autocomplete triggers on `$` showing only skill names
+ * - Works anywhere in the prompt (after space or at start)
+ */
+
+const DELIMITERS = new Set([" ", "\t", "\n"]);
+
+/** Find the `$token` at the cursor, or null if not in one. */
+function extractDollarPrefix(textBeforeCursor: string): string | null {
+  // Walk backwards to find the start of the current token
+  for (let i = textBeforeCursor.length - 1; i >= 0; i--) {
+    const char = textBeforeCursor[i];
+    if (char && DELIMITERS.has(char)) {
+      // Hit a delimiter — the token starts at i+1
+      const token = textBeforeCursor.slice(i + 1);
+      return token.startsWith("$") ? token : null;
+    }
+  }
+  // Reached start of line
+  return textBeforeCursor.startsWith("$") ? textBeforeCursor : null;
+}
+
+// ── Extension entry point ─────────────────────────────────────────
+
+/**
+ * Register `$skill-name` → `/skill:skill-name` expansion and autocomplete.
+ *
+ * ## Behavior gotchas
+ *
+ * - Installed skill names are snapshotted at `session_start` via
+ *   `pi.getCommands()`; after adding or removing skills, use `/reload` or
+ *   start a new session before testing expansion behavior.
+ * - Outside `$...` tokens, autocomplete must delegate back to the current
+ *   provider so built-in completion and file completion continue to work.
+ *
+ * ## Testing
+ *
+ * If behavior changes, test both:
+ * - expansion inside `$...` tokens
+ * - normal autocomplete everywhere else
+ */
+export default function (pi: ExtensionAPI) {
+  let skillNames: string[] = [];
+  let skillCommands: { name: string; description?: string }[] = [];
+
+  pi.on("session_start", (_event, ctx) => {
+    const commands = pi.getCommands();
+    skillCommands = commands
+      .filter((c) => c.source === "skill")
+      .map((c) => ({
+        name: c.name.replace(/^skill:/, ""),
+        description: c.description,
+      }));
+    skillNames = skillCommands.map((c) => c.name);
+
+    // Stack skill autocomplete on top of the built-in provider.
+    // addAutocompleteProvider takes a wrapper callback: (current) => provider.
+    ctx.ui.addAutocompleteProvider((current) => ({
+      async getSuggestions(lines, cursorLine, cursorCol, options) {
+        const textBeforeCursor = (lines[cursorLine] || "").slice(0, cursorCol);
+        const dollarPrefix = extractDollarPrefix(textBeforeCursor);
+
+        if (!dollarPrefix || dollarPrefix.includes(" ")) {
+          return current.getSuggestions(lines, cursorLine, cursorCol, options);
+        }
+
+        const query = dollarPrefix.slice(1);
+        const items = skillCommands.map((c) => ({
+          name: c.name,
+          description: c.description,
+        }));
+        const filtered = fuzzyFilter(items, query, (i) => i.name).map((i) => ({
+          value: i.name,
+          label: i.name,
+          ...(i.description && { description: i.description }),
+        }));
+        return filtered.length
+          ? { items: filtered, prefix: dollarPrefix }
+          : current.getSuggestions(lines, cursorLine, cursorCol, options);
+      },
+      // biome-ignore lint/complexity/useMaxParams: AutocompleteProvider interface
+      applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+        if (prefix.startsWith("$")) {
+          const line = lines[cursorLine] || "";
+          const before = line.slice(0, cursorCol - prefix.length);
+          const after = line.slice(cursorCol);
+          const newLine = `${before}$${item.value} ${after}`;
+          return {
+            lines: [...lines.slice(0, cursorLine), newLine, ...lines.slice(cursorLine + 1)],
+            cursorLine,
+            cursorCol: before.length + 1 + item.value.length + 1,
+          };
+        }
+        return current.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
+      },
+      shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
+        return current.shouldTriggerFileCompletion?.(lines, cursorLine, cursorCol) ?? true;
+      },
+    }));
+  });
+
+  // Transform $skill-name → /skill:skill-name before agent processing
+  pi.on("input", (event) => {
+    const text = event.text.trim();
+
+    // Find all $skill-name tokens and replace them
+    const transformed = text.replace(/(?:^|(?<=\s))\$([a-z0-9][-a-z0-9]*)/g, (_match, name) => {
+      return skillNames.includes(name) ? `/skill:${name}` : _match;
+    });
+
+    if (transformed !== text) {
+      return { action: "transform" as const, text: transformed };
+    }
+    return { action: "continue" as const };
+  });
+}

package/src/tab-spinner.ts

@@ -0,0 +1,125 @@
+/**
+ * Terminal tab title spinner for pi.
+ *
+ * Shows a braille spinner in the terminal tab title while the agent is working.
+ * Recomputes the base title dynamically on every tick so that `/name` renames
+ * and cwd changes are picked up automatically.
+ *
+ * Also activates during long-running extension tasks such as `supi-review`.
+ * When the agent turn ends, a ✓ symbol is shown persistently until the next
+ * agent starts or the session shuts down.
+ */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { formatTitle, signalDone } from "@mrclrchtr/supi-core";
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+export default function tabSpinner(pi: ExtensionAPI) {
+  let timer: ReturnType<typeof setInterval> | null = null;
+  let frame = 0;
+  let activeCount = 0;
+  let hasActiveAgent = false;
+  let askUserActive = 0;
+  let currentCtx: ExtensionContext | undefined;
+
+  /** Build the current base title from session name and cwd. */
+  function title() {
+    return formatTitle(pi.getSessionName(), currentCtx?.cwd);
+  }
+
+  /** Restore the base title immediately. */
+  function stop() {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+    frame = 0;
+    if (currentCtx) {
+      currentCtx.ui.setTitle(title());
+    }
+  }
+
+  /** Show the ✓ done symbol in the title and play the terminal bell. */
+  function showDone() {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+    frame = 0;
+    if (currentCtx) {
+      signalDone(currentCtx, title());
+    }
+  }
+
+  /** Start the spinner interval. Overwrites any ✓ shown. */
+  function start() {
+    if (timer) return;
+    if (!currentCtx) return;
+    timer = setInterval(() => {
+      const icon = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
+      currentCtx?.ui.setTitle(`${icon} ${title()}`);
+      frame++;
+    }, 80);
+  }
+
+  function increment(ctx: ExtensionContext) {
+    currentCtx = ctx;
+    activeCount++;
+    if (activeCount === 1) start();
+  }
+
+  /** Decrement count for supi:working tasks — restores title when idle. */
+  function decrement() {
+    const floor = hasActiveAgent ? 1 : 0;
+    activeCount = Math.max(floor, activeCount - 1);
+    if (activeCount === 0) stop();
+  }
+
+  /** Decrement count for agent turns — shows ✓ when idle. */
+  function agentEnded() {
+    activeCount = Math.max(0, activeCount - 1);
+    if (activeCount === 0) showDone();
+  }
+
+  pi.on("agent_start", async (_event, ctx) => {
+    hasActiveAgent = true;
+    increment(ctx);
+  });
+
+  pi.on("agent_end", async (_event, _ctx) => {
+    hasActiveAgent = false;
+    agentEnded();
+  });
+
+  pi.on("session_shutdown", async (_event, ctx) => {
+    activeCount = 0;
+    currentCtx = ctx;
+    stop();
+  });
+
+  pi.events.on("supi:working:start", () => {
+    if (currentCtx) increment(currentCtx);
+  });
+
+  pi.events.on("supi:working:end", () => {
+    decrement();
+  });
+
+  pi.events.on("supi:ask-user:start", () => {
+    askUserActive++;
+    // Pause the spinner so ask_user's attention title (set via signalWaiting)
+    // is visible to the user instead of being overwritten on the next tick.
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  });
+
+  pi.events.on("supi:ask-user:end", () => {
+    askUserActive = Math.max(0, askUserActive - 1);
+    if (askUserActive === 0 && activeCount > 0) {
+      // Resume the spinner if the agent (or background work) is still running.
+      start();
+    }
+  });
+}