@esso0428/pi-subagents 0.15.5 → 0.15.7

package/src/ui/conversation-blocks.ts

@@ -0,0 +1,404 @@
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+
+export type ConversationBlockKind = "text" | "tool" | "meta";
+export type ConversationBlockRole = "user" | "assistant" | "tool" | "custom" | "meta";
+
+/** The durable result snapshot attached to a normalized tool block. */
+export interface ConversationToolResultSnapshot {
+  toolCallId?: string;
+  toolName?: string;
+  content?: unknown;
+  details?: unknown;
+  isError?: boolean;
+}
+
+export interface ConversationBlock {
+  id: string;
+  kind: ConversationBlockKind;
+  role: ConversationBlockRole;
+  header: string;
+  markdown: string;
+  copyText: string;
+  fullText: string;
+  toolLine?: string;
+  /** Stable call id, including a synthetic id when the provider omitted one. */
+  toolCallId?: string;
+  toolName?: string;
+  /** Original tool arguments are retained for rich input rendering. */
+  toolArguments?: unknown;
+  /** Compatibility-facing short alias used by the timeline renderer. */
+  args?: unknown;
+  /** Result details/content are retained for rich output and durable diff rendering. */
+  toolResult?: ConversationToolResultSnapshot;
+  /** Compatibility-facing short alias used by the timeline renderer. */
+  result?: ConversationToolResultSnapshot;
+  toolStatus?: "pending" | "success" | "error";
+}
+
+export interface ConversationFormatOptions {
+  maxEntryChars?: number;
+  maxToolResultChars?: number;
+}
+
+const DEFAULT_MAX_CHARS = 16_000;
+const TRUNCATION_NOTICE = "\n… [truncated in subagent viewer]";
+
+type UnknownMessage = {
+  role?: unknown;
+  content?: unknown;
+  summary?: unknown;
+  command?: unknown;
+  output?: unknown;
+  toolName?: unknown;
+  toolCallId?: unknown;
+  id?: unknown;
+  name?: unknown;
+  details?: unknown;
+  isError?: unknown;
+  customType?: unknown;
+  display?: unknown;
+};
+
+type UnknownToolCall = Record<string, unknown>;
+
+function charLimit(value: number | undefined, fallback: number): number {
+  if (value === undefined || !Number.isFinite(value)) return fallback;
+  return Math.max(0, Math.floor(value));
+}
+
+/** Normalize terminal/platform line endings, then keep the result bounded. */
+function bound(value: string, limit: number): string {
+  const text = value.replace(/\r\n?/g, "\n");
+  if (text.length <= limit) return text;
+  if (limit <= 0) return "";
+  if (limit <= TRUNCATION_NOTICE.length) return TRUNCATION_NOTICE.slice(0, limit);
+  return text.slice(0, limit - TRUNCATION_NOTICE.length) + TRUNCATION_NOTICE;
+}
+
+function asString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+/** Extract displayable text without leaking provider-specific or unknown parts. */
+function contentText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+
+  const parts: string[] = [];
+  for (const part of content) {
+    if (!part || typeof part !== "object") continue;
+    const item = part as Record<string, unknown>;
+    if (item.type === "text" && typeof item.text === "string") {
+      parts.push(item.text);
+    } else if (item.type === "image") {
+      parts.push("[image]");
+    }
+  }
+  return parts.join("\n");
+}
+
+function firstNonEmptyLine(text: string): string {
+  const line = text.split("\n").find((candidate) => candidate.trim().length > 0);
+  if (!line) return "(no output)";
+  return line.trim().replace(/\s+/g, " ");
+}
+
+function toolSummary(name: string, call: UnknownToolCall): string {
+  const args = call.arguments && typeof call.arguments === "object"
+    ? call.arguments as Record<string, unknown>
+    : call.input && typeof call.input === "object"
+      ? call.input as Record<string, unknown>
+      : {};
+
+  const path = asString(args.path) ?? asString(args.filePath) ?? asString(args.filename);
+  if (["read", "edit", "write"].includes(name) && path) return path;
+  if (asString(args.command)) return asString(args.command)!;
+  if (path) return path;
+  try {
+    const encoded = JSON.stringify(args);
+    return encoded === "{}" ? "" : encoded;
+  } catch {
+    return "";
+  }
+}
+
+function blockId(messageIndex: number, emitted: number, toolIndex?: number): string {
+  if (emitted === 0) return `message-${messageIndex}`;
+  return `message-${messageIndex}-tool-${toolIndex ?? emitted}`;
+}
+
+function uniqueBlockId(preferred: string, used: Set<string>): string {
+  if (!used.has(preferred)) {
+    used.add(preferred);
+    return preferred;
+  }
+  let suffix = 2;
+  while (used.has(`${preferred}-${suffix}`)) suffix++;
+  const id = `${preferred}-${suffix}`;
+  used.add(id);
+  return id;
+}
+
+function textBlock(
+  id: string,
+  role: "user" | "assistant",
+  markdown: string,
+): ConversationBlock {
+  return {
+    id,
+    kind: "text",
+    role,
+    header: role === "user" ? "User" : "Assistant",
+    markdown,
+    copyText: markdown,
+    fullText: markdown,
+  };
+}
+
+function toolCallBlock(
+  id: string,
+  callId: string,
+  name: string,
+  call: UnknownToolCall,
+  summary: string,
+): ConversationBlock {
+  const toolLine = `· ${name} → ${summary || "(no details)"}`;
+  return {
+    id,
+    kind: "tool",
+    role: "tool",
+    header: name,
+    markdown: "",
+    copyText: toolLine,
+    fullText: toolLine,
+    toolLine,
+    toolCallId: callId,
+    toolName: name,
+    toolArguments: call.arguments ?? call.input,
+    args: call.arguments ?? call.input,
+    toolStatus: "pending",
+  };
+}
+
+function resultSnapshot(message: UnknownMessage): ConversationToolResultSnapshot {
+  return {
+    toolCallId: asString(message.toolCallId) ?? asString(message.id),
+    toolName: asString(message.toolName) ?? asString(message.name),
+    content: message.content,
+    details: message.details,
+    isError: message.isError === true,
+  };
+}
+
+function applyToolResult(
+  block: ConversationBlock,
+  result: ConversationToolResultSnapshot,
+  maxChars: number,
+): void {
+  const name = result.toolName ?? block.toolName ?? "tool";
+  const normalized = contentText(result.content).replace(/\r\n?/g, "\n");
+  const success = result.isError ? "✗" : "✓";
+  const lineCount = normalized.length === 0 ? 0 : normalized.split("\n").length;
+  const charCount = normalized.length;
+  const summary = firstNonEmptyLine(normalized);
+  block.toolResult = result;
+  block.result = result;
+  block.toolStatus = result.isError ? "error" : "success";
+  block.toolName = name;
+  block.header = name;
+  block.copyText = bound(`${name} ${success}\n${normalized}`, maxChars);
+  block.fullText = block.copyText;
+  block.toolLine = `· ${name} ${success} ${summary} ${lineCount}L/${charCount}c`;
+}
+
+function orphanToolResultBlock(
+  id: string,
+  result: ConversationToolResultSnapshot,
+  maxChars: number,
+): ConversationBlock {
+  const name = result.toolName ?? "tool";
+  const output = contentText(result.content).replace(/\r\n?/g, "\n");
+  const success = result.isError ? "✗" : "✓";
+  const lineCount = output.length === 0 ? 0 : output.split("\n").length;
+  const charCount = output.length;
+  const summary = firstNonEmptyLine(output);
+  const toolLine = `· ${name} ${success} ${summary} ${lineCount}L/${charCount}c`;
+  const fullText = bound(`${name} ${success}\n${output}`, maxChars);
+  return {
+    id,
+    kind: "tool",
+    role: "tool",
+    header: `${name} result`,
+    markdown: "",
+    copyText: fullText,
+    fullText,
+    toolLine,
+    toolCallId: result.toolCallId,
+    toolName: name,
+    toolResult: result,
+    result,
+    toolStatus: result.isError ? "error" : "success",
+  };
+}
+
+function bashBlock(
+  id: string,
+  message: UnknownMessage,
+  maxChars: number,
+): ConversationBlock {
+  const command = asString(message.command) ?? "";
+  const output = asString(message.output) ?? contentText(message.content);
+  const body = command ? `$ ${command}${output ? `\n${output}` : ""}` : output;
+  const toolLine = `· bash → ${command || "(no command)"}`;
+  const fullText = bound(body, maxChars);
+  return {
+    id,
+    kind: "tool",
+    role: "tool",
+    header: "bash",
+    markdown: "",
+    copyText: fullText,
+    fullText,
+    toolLine,
+    toolName: "bash",
+  };
+}
+
+function metaBlock(
+  id: string,
+  header: string,
+  value: unknown,
+  maxChars: number,
+): ConversationBlock | undefined {
+  const text = typeof value === "string" ? value : contentText(value);
+  const markdown = bound(text, maxChars);
+  if (!markdown.trim()) return undefined;
+  return {
+    id,
+    kind: "meta",
+    role: "meta",
+    header,
+    markdown,
+    copyText: markdown,
+    fullText: markdown,
+  };
+}
+
+/**
+ * Convert provider messages into stable, render-oriented blocks.
+ *
+ * Tool results are attached to the original call when possible. This keeps the
+ * block in call/source order while preserving the complete result snapshot for
+ * rich rendering. Results that cannot be matched remain visible as orphan cards.
+ */
+export function formatConversationMessages(
+  messages: AgentSession["messages"],
+  options?: ConversationFormatOptions,
+): ConversationBlock[] {
+  const maxEntryChars = charLimit(options?.maxEntryChars, DEFAULT_MAX_CHARS);
+  const maxToolResultChars = charLimit(options?.maxToolResultChars, DEFAULT_MAX_CHARS);
+  const blocks: ConversationBlock[] = [];
+  const usedBlockIds = new Set<string>();
+  const callsById = new Map<string, ConversationBlock>();
+  const callsByName = new Map<string, ConversationBlock[]>();
+
+  const registerCall = (name: string, block: ConversationBlock) => {
+    callsById.set(block.toolCallId!, block);
+    const nameKey = name.toLowerCase();
+    const candidates = callsByName.get(nameKey) ?? [];
+    candidates.push(block);
+    callsByName.set(nameKey, candidates);
+  };
+  const unregisterCall = (block: ConversationBlock) => {
+    if (block.toolCallId) callsById.delete(block.toolCallId);
+    const nameKey = (block.toolName ?? "tool").toLowerCase();
+    const candidates = callsByName.get(nameKey);
+    if (!candidates) return;
+    const index = candidates.indexOf(block);
+    if (index >= 0) candidates.splice(index, 1);
+    if (candidates.length === 0) callsByName.delete(nameKey);
+  };
+
+  for (let messageIndex = 0; messageIndex < messages.length; messageIndex++) {
+    const message = messages[messageIndex] as unknown as UnknownMessage;
+    const role = message?.role;
+    let emitted = 0;
+
+    if (role === "user") {
+      const text = bound(contentText(message.content), maxEntryChars);
+      if (text.trim()) {
+        blocks.push(textBlock(uniqueBlockId(blockId(messageIndex, emitted), usedBlockIds), "user", text));
+      }
+      continue;
+    }
+
+    if (role === "assistant") {
+      const parts = Array.isArray(message.content) ? message.content : [];
+      const text = bound(contentText(parts), maxEntryChars);
+      if (text.trim()) {
+        blocks.push(textBlock(uniqueBlockId(blockId(messageIndex, emitted++), usedBlockIds), "assistant", text));
+      }
+
+      let toolIndex = 0;
+      for (const part of parts) {
+        if (!part || typeof part !== "object" || (part as any).type !== "toolCall") continue;
+        const call = part as UnknownToolCall;
+        const name = asString(call.name) ?? asString(call.toolName) ?? "unknown";
+        const preferredId = asString(call.id) ?? asString(call.toolCallId)
+          ?? `message-${messageIndex}-tool-${toolIndex}`;
+        const callId = callsById.has(preferredId)
+          ? uniqueBlockId(preferredId, new Set(callsById.keys()))
+          : preferredId;
+        const block = toolCallBlock(
+          uniqueBlockId(blockId(messageIndex, emitted++, toolIndex), usedBlockIds),
+          callId,
+          name,
+          call,
+          toolSummary(name, call),
+        );
+        blocks.push(block);
+        registerCall(name, block);
+        toolIndex++;
+      }
+      continue;
+    }
+
+    if (role === "toolResult") {
+      const result = resultSnapshot(message);
+      const direct = result.toolCallId ? callsById.get(result.toolCallId) : undefined;
+      let match = direct;
+      if (!match && result.toolName) {
+        match = callsByName.get(result.toolName.toLowerCase())?.[0];
+      }
+      if (match) {
+        applyToolResult(match, result, maxToolResultChars);
+        unregisterCall(match);
+      } else {
+        const preferred = blockId(messageIndex, emitted);
+        blocks.push(orphanToolResultBlock(uniqueBlockId(preferred, usedBlockIds), result, maxToolResultChars));
+      }
+      continue;
+    }
+
+    if (role === "bashExecution") {
+      blocks.push(bashBlock(uniqueBlockId(blockId(messageIndex, emitted), usedBlockIds), message, maxToolResultChars));
+      continue;
+    }
+
+    if (role === "custom") {
+      if (message.display === false) continue;
+      const header = asString(message.customType) || "Custom";
+      const block = metaBlock(uniqueBlockId(blockId(messageIndex, emitted), usedBlockIds), header, message.content, maxEntryChars);
+      if (block) blocks.push({ ...block, role: "custom" });
+      continue;
+    }
+
+    if (role === "compactionSummary" || role === "branchSummary" || role === "summary") {
+      const header = role === "summary" ? "Summary" : role === "compactionSummary" ? "Compaction summary" : "Branch summary";
+      const block = metaBlock(uniqueBlockId(blockId(messageIndex, emitted), usedBlockIds), header, message.summary, maxEntryChars);
+      if (block) blocks.push(block);
+    }
+  }
+
+  return blocks;
+}

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-role.ts

@@ -0,0 +1,45 @@
+import type { Component } from "@earendil-works/pi-tui";
+import type { ConversationBlock } from "./conversation-blocks.js";
+import type { Theme } from "./agent-widget.js";
+
+export type ConversationRoleTheme = Pick<Theme, "fg">;
+
+/**
+ * Render a semantic role label without coloring the whole message body.
+ * These names intentionally mirror the labels used by peek-style viewers.
+ */
+export function conversationRoleLabel(block: ConversationBlock): string {
+  if (block.kind === "tool") return (block.toolName || "TOOL").toUpperCase();
+  if (block.role === "user") return "USER";
+  if (block.role === "assistant") return "ASSISTANT";
+  if (block.role === "custom") return block.header || "CUSTOM";
+  return block.header || "META";
+}
+
+export function renderConversationRoleHeader(
+  block: ConversationBlock,
+  theme: ConversationRoleTheme,
+): string {
+  const label = conversationRoleLabel(block);
+  const color = block.kind === "tool"
+    ? "toolTitle"
+    : block.role === "user"
+      ? "userMessageText"
+      : block.role === "assistant"
+        ? "accent"
+        : block.role === "custom"
+          ? "customMessageLabel"
+          : "muted";
+  const detail = block.kind === "tool" && block.toolCallId
+    ? theme.fg("dim", ` · ${block.toolCallId}`)
+    : "";
+  return `${theme.fg(color, label)}${detail}`;
+}
+
+/** Adapter useful to callers that need a Component-shaped role row. */
+export function conversationRoleComponent(block: ConversationBlock, theme: ConversationRoleTheme): Component {
+  return {
+    render: () => [` ${renderConversationRoleHeader(block, theme)}`],
+    invalidate() {},
+  };
+}