@esso0428/pi-subagents 0.15.4 → 0.15.6

package/src/ui/conversation-nvim.ts

@@ -0,0 +1,127 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { TUI } from "@earendil-works/pi-tui";
+import type { ConversationBlock } from "./conversation-blocks.js";
+
+const DEFAULT_EDITOR = "nvim";
+
+function safeFilename(role: string, id: string): string {
+  const safeRole = role.replace(/[^a-z0-9]/gi, "") || "message";
+  const safeId = id.replace(/[^a-z0-9]/gi, "").slice(0, 24) || "x";
+  return `${safeRole}-${safeId}.md`;
+}
+
+function vimStringLiteral(value: string): string {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+
+function notify(ctx: ExtensionContext, message: string, level: "error" | "warning" | "info" = "error"): void {
+  ctx.ui.notify(message, level);
+}
+
+function runFullscreen(tui: TUI, ctx: ExtensionContext, editor: string, args: string[]): number | null {
+  try {
+    tui.stop();
+    process.stdout.write("\x1b[2J\x1b[H");
+    const result = spawnSync(editor, args, {
+      cwd: ctx.cwd,
+      env: process.env,
+      stdio: "inherit",
+    });
+    if (result.error) {
+      notify(ctx, `${editor} failed: ${result.error.message}`);
+      return null;
+    }
+    return result.status;
+  } catch (error) {
+    notify(ctx, `${editor} failed: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  } finally {
+    try {
+      tui.start();
+      tui.requestRender(true);
+    } catch (error) {
+      notify(ctx, `Could not restore terminal UI: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}
+
+/** Open a bounded conversation block without allowing edits to the transcript. */
+export async function viewConversationBlockInNvim(
+  tui: TUI,
+  ctx: ExtensionContext,
+  block: ConversationBlock,
+): Promise<void> {
+  let dir: string | undefined;
+  try {
+    dir = await mkdtemp(path.join(tmpdir(), "pi-subagents-view-"));
+    const filePath = path.join(dir, safeFilename(block.role, block.id));
+    await writeFile(filePath, `${block.fullText}\n`, "utf8");
+    const editor = process.env.VISUAL || process.env.EDITOR || DEFAULT_EDITOR;
+    runFullscreen(tui, ctx, editor, ["-R", filePath]);
+  } catch (error) {
+    notify(ctx, `Could not open block in nvim: ${error instanceof Error ? error.message : String(error)}`);
+  } finally {
+    if (dir) {
+      try {
+        await rm(dir, { recursive: true, force: true });
+      } catch (error) {
+        notify(ctx, `Could not remove temporary nvim file: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+}
+
+/** Edit a live assistant block and send the saved text as a new user message. */
+export async function editLiveAssistantBlockInNvim(
+  pi: ExtensionAPI,
+  tui: TUI,
+  ctx: ExtensionContext,
+  block: ConversationBlock,
+): Promise<boolean> {
+  if (block.role !== "assistant") {
+    notify(ctx, "Only assistant messages can be edited and sent back", "warning");
+    return false;
+  }
+
+  let dir: string | undefined;
+  try {
+    dir = await mkdtemp(path.join(tmpdir(), "pi-subagents-edit-"));
+    const filePath = path.join(dir, safeFilename(block.role, block.id));
+    const savedPath = path.join(dir, "saved");
+    await writeFile(filePath, `${block.fullText}\n`, "utf8");
+    const editor = process.env.VISUAL || process.env.EDITOR || DEFAULT_EDITOR;
+    const autocmd = `autocmd BufWritePost <buffer> call writefile(['1'], ${vimStringLiteral(savedPath)}) | qall`;
+    const status = runFullscreen(tui, ctx, editor, ["-c", autocmd, filePath]);
+    if (status !== 0) {
+      notify(ctx, `${editor} exited with code ${status ?? "unknown"}`, "warning");
+      return false;
+    }
+    if (!existsSync(savedPath)) {
+      notify(ctx, "No save detected; nothing sent", "info");
+      return false;
+    }
+    const edited = (await readFile(filePath, "utf8")).trimEnd();
+    if (!edited.trim()) {
+      notify(ctx, "Saved text is empty; nothing sent", "warning");
+      return false;
+    }
+    pi.sendUserMessage(`I edited an earlier assistant response in Neovim. Treat this as my correction / direction:\n\n${edited}`);
+    return true;
+  } catch (error) {
+    notify(ctx, `Could not edit block in nvim: ${error instanceof Error ? error.message : String(error)}`);
+    return false;
+  } finally {
+    if (dir) {
+      try {
+        await rm(dir, { recursive: true, force: true });
+      } catch (error) {
+        notify(ctx, `Could not remove temporary nvim file: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+}

package/src/ui/conversation-search.ts

@@ -0,0 +1,161 @@
+/** Search and highlighting helpers for rendered conversation lines. */
+
+/** A substring match in a rendered line's plain-text representation. */
+export type ConversationMatch = {
+  lineIdx: number;
+  col: number;
+  len: number;
+};
+
+type ConversationLine = { plain: string };
+
+type HighlightMatch = ConversationMatch & { current?: boolean };
+
+function isSmartcaseInsensitive(query: string): boolean {
+  return query === query.toLowerCase();
+}
+
+/**
+ * Remove ANSI CSI/OSC control sequences from a string.
+ *
+ * This deliberately follows the escape-sequence grammar used by the terminal
+ * renderer, rather than stripping only colour codes: hyperlinks and other
+ * styled output must not affect plain-text search columns either.
+ */
+export function stripAnsi(text: string): string {
+  let result = "";
+  let i = 0;
+
+  while (i < text.length) {
+    if (text[i] !== "\x1b") {
+      result += text[i];
+      i++;
+      continue;
+    }
+
+    const match = text.slice(i).match(ANSI_ESCAPE_RE);
+    if (match) {
+      i += match[0].length;
+      continue;
+    }
+
+    // An incomplete escape sequence has no visible representation. This also
+    // prevents a malformed trailing escape from leaking into search text.
+    if (i + 1 < text.length) {
+      i += 2;
+    } else {
+      i++;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Find all non-overlapping substring matches using smartcase semantics.
+ * Lowercase queries match case-insensitively; queries containing uppercase
+ * characters match case-sensitively.
+ */
+export function findConversationMatches(
+  lines: ConversationLine[],
+  query: string,
+): ConversationMatch[] {
+  if (!query) return [];
+
+  const matches: ConversationMatch[] = [];
+  const caseInsensitive = isSmartcaseInsensitive(query);
+  const needle = caseInsensitive ? query.toLowerCase() : query;
+
+  for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+    const plain = lines[lineIdx]?.plain ?? "";
+    const haystack = caseInsensitive ? plain.toLowerCase() : plain;
+    let position = 0;
+
+    while (position < haystack.length) {
+      const col = haystack.indexOf(needle, position);
+      if (col === -1) break;
+      matches.push({ lineIdx, col, len: query.length });
+      position = col + Math.max(1, query.length);
+    }
+  }
+
+  return matches;
+}
+
+/**
+ * Inject match backgrounds into an ANSI-styled line without counting escape
+ * sequences as plain-text columns. Existing foreground/style sequences are
+ * copied verbatim, so syntax highlighting remains intact.
+ */
+export function highlightConversationLine(
+  text: string,
+  matches: HighlightMatch[],
+  openMatch: string,
+  openCurrent: string,
+  close: string,
+): string {
+  if (matches.length === 0) return text;
+
+  const sorted = [...matches].sort((a, b) => a.col - b.col);
+  let result = "";
+  let plainCol = 0;
+  let i = 0;
+  let active: HighlightMatch | null = null;
+  let nextIdx = 0;
+
+  while (i < text.length) {
+    if (text[i] === "\x1b") {
+      const escape = text.slice(i).match(ANSI_ESCAPE_RE);
+      if (escape) {
+        result += escape[0];
+        i += escape[0].length;
+        continue;
+      }
+    }
+
+    if (!active && nextIdx < sorted.length && plainCol >= sorted[nextIdx].col) {
+      active = sorted[nextIdx];
+      result += active.current ? openCurrent : openMatch;
+    }
+
+    result += text[i];
+    plainCol++;
+    i++;
+
+    if (active && plainCol >= active.col + active.len) {
+      result += close;
+      active = null;
+      nextIdx++;
+    }
+  }
+
+  if (active) result += close;
+  return result;
+}
+
+/** Find the first match at or after a line, wrapping to the first match. */
+export function nearestConversationMatchAfter(
+  matches: ConversationMatch[],
+  lineIdx: number,
+): number {
+  if (matches.length === 0) return -1;
+  for (let i = 0; i < matches.length; i++) {
+    if (matches[i].lineIdx >= lineIdx) return i;
+  }
+  return 0;
+}
+
+/** Find the last match at or before a line, wrapping to the last match. */
+export function nearestConversationMatchBefore(
+  matches: ConversationMatch[],
+  lineIdx: number,
+): number {
+  if (matches.length === 0) return -1;
+  for (let i = matches.length - 1; i >= 0; i--) {
+    if (matches[i].lineIdx <= lineIdx) return i;
+  }
+  return matches.length - 1;
+}
+
+/** ANSI CSI/OSC sequences emitted by the TUI renderer. */
+const ANSI_ESCAPE_RE = /^(?:\x1b\][^\x07]*(?:\x07|\x1b\\)|\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]))/;