@pi-archimedes/ui 2.9.0

package/src/bash/renderer.ts

@@ -0,0 +1,301 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { Text, truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
+import { renderToolHeader } from "@pi-archimedes/core/tool-render";
+
+export interface BashRendererState {
+  startedAt?: number | undefined;
+  endedAt?: number | undefined;
+  interval?: NodeJS.Timeout | undefined;
+  timeout?: number | undefined;
+  command?: string | undefined;
+}
+
+const activeStates = new Set<BashRendererState>();
+
+export function clearActiveBashIntervals(): void {
+  for (const state of activeStates) {
+    if (state.interval) {
+      clearInterval(state.interval);
+      state.interval = undefined;
+    }
+  }
+  activeStates.clear();
+}
+
+/**
+ * Format duration in milliseconds as:
+ * - <X.X>s for under 10 seconds (e.g. "1.5s")
+ * - <X>s for 10s to 60s (e.g. "15s")
+ * - <M>m <S>s for 60s and above (e.g. "1m 5s")
+ * - <H>h <M>m <S>s if exceeding 60 minutes
+ */
+export function formatDuration(ms: number): string {
+  if (ms < 0) ms = 0;
+  const seconds = ms / 1000;
+  if (seconds < 10) {
+    return `${seconds.toFixed(1)}s`;
+  }
+  const totalSeconds = Math.floor(seconds);
+  if (totalSeconds < 60) {
+    return `${totalSeconds}s`;
+  }
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  const remainderSeconds = totalSeconds % 60;
+  if (totalMinutes < 60) {
+    return `${totalMinutes}m ${remainderSeconds}s`;
+  }
+  const hours = Math.floor(totalMinutes / 60);
+  const remainderMinutes = totalMinutes % 60;
+  return `${hours}h ${remainderMinutes}m ${remainderSeconds}s`;
+}
+
+/**
+ * Component that renders single-line text dynamically truncated to the
+ * viewport/terminal width via truncateToWidth.
+ */
+export class TruncatedTextComponent implements Component {
+  private text: string = "";
+  private theme: Theme | undefined = undefined;
+
+  constructor(text: string = "", theme?: Theme | undefined) {
+    this.text = text;
+    this.theme = theme;
+  }
+
+  setText(text: string): void {
+    this.text = text;
+  }
+
+  setTheme(theme?: Theme | undefined): void {
+    this.theme = theme;
+  }
+
+  getContent(): string {
+    return this.text;
+  }
+
+  invalidate(): void {}
+
+  render(width: number): string[] {
+    if (!this.text) return [""];
+    const singleLine = this.text.replace(/[\r\n]+/g, " ");
+    const ellipsis = this.theme ? this.theme.fg("accent", "…") : "…";
+    const truncated = truncateToWidth(singleLine, width, ellipsis);
+    const padNeeded = Math.max(0, width - visibleWidth(truncated));
+    return [truncated + " ".repeat(padNeeded)];
+  }
+}
+
+/**
+ * Format a bash command for display in the tool header line.
+ * Normalizes newlines to spaces and trims whitespace.
+ * If maxLength is specified, truncates via truncateToWidth with an ellipsis.
+ */
+export function formatBashCommand(command?: string, maxLength?: number): string | undefined {
+  if (typeof command !== "string") return undefined;
+  const oneLine = command.replace(/[\r\n]+/g, " ").trim();
+  if (!oneLine) return undefined;
+  if (typeof maxLength === "number" && maxLength > 0) {
+    return truncateToWidth(oneLine, maxLength, "…");
+  }
+  return oneLine;
+}
+
+function getCallComponent(context: unknown): TruncatedTextComponent {
+  const ctx = context as { lastComponent?: unknown } | undefined;
+  if (ctx?.lastComponent instanceof TruncatedTextComponent) {
+    return ctx.lastComponent;
+  }
+  return new TruncatedTextComponent("");
+}
+
+function getTextComponent(context: unknown): Text {
+  const ctx = context as { lastComponent?: unknown } | undefined;
+  if (ctx?.lastComponent instanceof Text) {
+    return ctx.lastComponent;
+  }
+  return new Text("", 0, 0);
+}
+
+/**
+ * Render the bash tool call line with bold header and command in accent color.
+ * Truncates dynamically to the viewport width at render time.
+ *
+ * Line 1: `bash` (bold toolTitle) + command (accent)
+ */
+export function renderBashCall(args: unknown, theme: Theme, context: unknown): TruncatedTextComponent {
+  const ctx = context as {
+    executionStarted?: boolean;
+    state?: BashRendererState;
+    args?: { command?: string; timeout?: number };
+  } | undefined;
+
+  const rawCmd =
+    (args as { command?: string; timeout?: number } | undefined)?.command ??
+    ctx?.args?.command;
+  const timeout =
+    (args as { timeout?: number } | undefined)?.timeout ?? ctx?.args?.timeout;
+
+  if (ctx) {
+    if (!ctx.state) {
+      ctx.state = {};
+    }
+    if (ctx.executionStarted && ctx.state.startedAt === undefined) {
+      ctx.state.startedAt = Date.now();
+      ctx.state.endedAt = undefined;
+    }
+    if (typeof timeout === "number" && Number.isFinite(timeout)) {
+      ctx.state.timeout = timeout;
+    }
+    if (typeof rawCmd === "string") {
+      ctx.state.command = rawCmd;
+    }
+  }
+
+  const comp = getCallComponent(context);
+  comp.setTheme(theme);
+  const displayCmd = formatBashCommand(rawCmd);
+  comp.setText(renderToolHeader("bash", displayCmd, theme));
+  return comp;
+}
+
+/**
+ * Render the bash tool result line (collapsed or expanded view).
+ */
+export function renderBashResult(
+  result: unknown,
+  options: { expanded?: boolean; isPartial?: boolean },
+  theme: Theme,
+  context: unknown,
+): Text {
+  const ctx = context as {
+    executionStarted?: boolean;
+    isError?: boolean;
+    state?: BashRendererState;
+    args?: { command?: string; timeout?: number };
+    invalidate?: () => void;
+  } | undefined;
+
+  const state: BashRendererState = ctx?.state ?? {};
+  if (ctx && !ctx.state) {
+    ctx.state = state;
+  }
+
+  if ((ctx?.executionStarted || options.isPartial) && state.startedAt === undefined) {
+    state.startedAt = Date.now();
+  }
+
+  if (options.isPartial && !state.interval) {
+    if (ctx?.invalidate) {
+      state.interval = setInterval(() => {
+        ctx.invalidate?.();
+      }, 1000);
+      activeStates.add(state);
+    }
+  }
+
+  if (!options.isPartial || ctx?.isError) {
+    state.endedAt ??= Date.now();
+    if (state.interval) {
+      clearInterval(state.interval);
+      state.interval = undefined;
+    }
+    activeStates.delete(state);
+  }
+
+  const res = result as {
+    content?: Array<{ type: string; text?: string }>;
+    details?: {
+      truncation?: {
+        truncated?: boolean;
+        outputLines?: number;
+        totalLines?: number;
+      };
+      fullOutputPath?: string;
+      exitCode?: number;
+    };
+    isError?: boolean;
+    exitCode?: number;
+  } | undefined;
+
+  const isError = Boolean(ctx?.isError || res?.isError || result instanceof Error);
+  const now = Date.now();
+  const startTime = state.startedAt ?? (state.endedAt ?? now);
+  const endTime = state.endedAt ?? now;
+  const elapsed = Math.max(0, endTime - startTime);
+
+  const textComponent = getTextComponent(context);
+
+  if (!options.expanded) {
+    // Collapsed view:
+    // `<status> <timer> (timeout: <timeout value>)`
+    const statusGlyph = options.isPartial
+      ? theme.fg("warning", "▸")
+      : isError
+        ? theme.fg("error", "✗")
+        : theme.fg("success", "✓");
+
+    const timeout = ctx?.args?.timeout ?? state.timeout;
+    const timeoutSuffix =
+      typeof timeout === "number" && Number.isFinite(timeout)
+        ? theme.fg("dim", ` (timeout: ${timeout}s)`)
+        : "";
+
+    const styledDuration = theme.fg("muted", formatDuration(elapsed));
+
+    textComponent.setText(`${statusGlyph} ${styledDuration}${timeoutSuffix}`);
+    return textComponent;
+  }
+
+  // Expanded view:
+  const parts: string[] = [];
+  const rawCmd =
+    typeof ctx?.args?.command === "string"
+      ? ctx.args.command
+      : (state.command ?? "");
+  parts.push(theme.fg("dim", "$ ") + theme.fg("toolOutput", rawCmd));
+
+  const textBlocks = Array.isArray(res?.content)
+    ? res.content.filter((b) => b && b.type === "text" && typeof b.text === "string")
+    : [];
+
+  const rawOutput = textBlocks.map((b) => b.text!).join("\n");
+  if (rawOutput.length > 0) {
+    const lines = rawOutput.split("\n");
+    for (const line of lines) {
+      parts.push(theme.fg(isError ? "error" : "toolOutput", line));
+    }
+  }
+
+  if (res?.details?.truncation?.truncated) {
+    const truncation = res.details.truncation;
+    parts.push(
+      theme.fg(
+        "warning",
+        `[Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines. Full output: ${res.details.fullOutputPath}]`,
+      ),
+    );
+  }
+
+  const durationLabel = options.isPartial ? "Elapsed" : "Took";
+  parts.push(theme.fg("muted", `${durationLabel} ${formatDuration(elapsed)}`));
+
+  if (!options.isPartial) {
+    if (isError) {
+      const exitMatch = rawOutput.match(/(?:Command exited with code|exit code:?)\s*(\d+)/i);
+      const code = exitMatch
+        ? exitMatch[1]
+        : typeof res?.details?.exitCode === "number"
+          ? String(res.details.exitCode)
+          : typeof res?.exitCode === "number"
+            ? String(res.exitCode)
+            : "1";
+      parts.push(theme.fg("error", `✗ Command exited with code ${code}`));
+    } else {
+      parts.push(theme.fg("success", "✓ Done"));
+    }
+  }
+
+  textComponent.setText(parts.join("\n"));
+  return textComponent;
+}

package/src/bash/tool.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect, vi } from "vitest";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerBashToolOverride } from "./tool.js";
+import { renderBashCall, renderBashResult } from "./renderer.js";
+
+describe("registerBashToolOverride", () => {
+  it("registers bash tool with custom renderCall and renderResult while preserving definition", () => {
+    let capturedTool: any = null;
+    const pi = {
+      registerTool: vi.fn((tool: any) => {
+        capturedTool = tool;
+      }),
+    } as unknown as ExtensionAPI;
+
+    registerBashToolOverride(pi, "/test/cwd");
+
+    expect(pi.registerTool).toHaveBeenCalledTimes(1);
+    expect(capturedTool).toBeDefined();
+    expect(capturedTool.name).toBe("bash");
+    expect(capturedTool.label).toBe("bash");
+    expect(capturedTool.parameters).toBeDefined();
+    expect(typeof capturedTool.execute).toBe("function");
+    expect(capturedTool.renderCall).toBe(renderBashCall);
+    expect(capturedTool.renderResult).toBe(renderBashResult);
+  });
+});

package/src/bash/tool.ts

@@ -0,0 +1,17 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createBashToolDefinition } from "@earendil-works/pi-coding-agent";
+import { renderBashCall, renderBashResult } from "./renderer.js";
+
+/**
+ * Register custom styled bash tool override.
+ * Preserves core execution, parameters, timeouts, and PI_* environment injection
+ * while replacing the presentation with Archimedes styled rendering.
+ */
+export function registerBashToolOverride(pi: ExtensionAPI, cwd: string): void {
+  const def = createBashToolDefinition(cwd);
+  pi.registerTool({
+    ...def,
+    renderCall: renderBashCall,
+    renderResult: renderBashResult,
+  });
+}

package/src/codemode/index.ts

@@ -0,0 +1,20 @@
+export {
+  loadCodemodeModule,
+  resolveCodemodeModuleFiles,
+  findAgentPackageRoot,
+  type CodemodeToolModule,
+} from "./loader.js";
+export {
+  renderCodemodeCall,
+  renderCodemodeResult,
+  formatCodemodeDuration,
+  formatCost,
+  formatNestedCall,
+  getCodemodeOutput,
+  parseWallTimeMs,
+  clearActiveCodemodeIntervals,
+  type CodemodeNestedCall,
+  type CodemodeToolDetails,
+  type CodemodeRendererState,
+} from "./renderer.js";
+export { registerCodemodeToolOverride } from "./tool.js";

package/src/codemode/loader.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import {
+  findAgentPackageRoot,
+  resolveCodemodeModuleFiles,
+  loadCodemodeModule,
+} from "./loader.js";
+
+const createdDirs: string[] = [];
+
+function makeTree(
+  rootName: string,
+  files: Record<string, string>,
+): string {
+  const root = mkdtempSync(path.join(tmpdir(), `archimedes-${rootName}-`));
+  createdDirs.push(root);
+  for (const [rel, content] of Object.entries(files)) {
+    const file = path.join(root, rel);
+    mkdirSync(path.dirname(file), { recursive: true });
+    writeFileSync(file, content);
+  }
+  return root;
+}
+
+afterEach(() => {
+  for (const dir of createdDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+  vi.unstubAllEnvs();
+});
+
+describe("findAgentPackageRoot", () => {
+  it("finds the package root from a nested dist file", () => {
+    const root = makeTree("agent", {
+      "package.json": JSON.stringify({ name: "@earendil-works/pi-coding-agent" }),
+      "dist/index.js": "",
+      "dist/extensions/codemode/tool.js": "",
+    });
+    expect(
+      findAgentPackageRoot(path.join(root, "dist", "extensions", "codemode")),
+    ).toBe(root);
+    expect(findAgentPackageRoot(path.join(root, "dist"))).toBe(root);
+  });
+
+  it("returns undefined for another package", () => {
+    const root = makeTree("other", {
+      "package.json": JSON.stringify({ name: "@pi-archimedes/ui" }),
+      "src/index.ts": "",
+    });
+    expect(findAgentPackageRoot(path.join(root, "src"))).toBeUndefined();
+  });
+
+  it("returns undefined when there is no package.json at all", () => {
+    const root = makeTree("loose", { "some/file.js": "" });
+    expect(findAgentPackageRoot(root)).toBeUndefined();
+  });
+});
+
+describe("resolveCodemodeModuleFiles", () => {
+  it("resolves the codemode module from the CLI entry script (argv[1])", () => {
+    const root = makeTree("agent", {
+      "package.json": JSON.stringify({ name: "@earendil-works/pi-coding-agent" }),
+      "dist/bundle/cli.js": "",
+      "dist/extensions/codemode/tool.js": "",
+    });
+    const files = resolveCodemodeModuleFiles(
+      path.join(root, "dist", "bundle", "cli.js"),
+    );
+    expect(files).toContain(
+      path.join(root, "dist", "extensions", "codemode", "tool.js"),
+    );
+  });
+
+  it("returns no argv[1] candidate when the entry is not in the agent package", () => {
+    const files = resolveCodemodeModuleFiles("/usr/bin/some-other-cli");
+    // Only the local-copy candidate (if any) may remain.
+    for (const file of files) {
+      expect(file).not.toContain("/usr/bin/some-other-cli");
+    }
+  });
+
+  it("returns an empty list without argv[1] and without a local copy", () => {
+    // createRequire fallback: the local pi-coding-agent copy in this repo has
+    // no dist/extensions/codemode in older versions, but the resolution
+    // itself must not throw.
+    expect(() => resolveCodemodeModuleFiles(undefined)).not.toThrow();
+  });
+
+  it("never builds a dist/dist path for the local-copy candidate", () => {
+    // require.resolve() returns …/pi-coding-agent/dist/index.js — its
+    // directory IS the dist dir, so joining another `dist` segment would
+    // produce a nonexistent …/dist/dist/… path and silently disable the
+    // override for launcher entries outside the agent package.
+    const files = resolveCodemodeModuleFiles(undefined);
+    for (const file of files) {
+      expect(file).not.toContain(path.join("dist", "dist"));
+    }
+  });
+});
+
+describe("loadCodemodeModule", () => {
+  it("loads the module when the file exists and exports the factory", async () => {
+    const root = makeTree("agent", {
+      "package.json": JSON.stringify({ name: "@earendil-works/pi-coding-agent" }),
+      "dist/index.js": "",
+      "dist/extensions/codemode/tool.js": `
+        export const codemodeSchema = { type: "object" };
+        export function createCodemodeToolDefinition(options) {
+          return { options, parameters: codemodeSchema };
+        }
+      `,
+    });
+    const mod = await loadCodemodeModule(
+      path.join(root, "dist", "index.js"),
+    );
+    expect(mod).toBeDefined();
+    expect(mod!.createCodemodeToolDefinition).toBeTypeOf("function");
+    expect(mod!.codemodeSchema).toEqual({ type: "object" });
+  });
+
+  it("returns undefined when the module file is missing", async () => {
+    const mod = await loadCodemodeModule("/does/not/exist/cli.js");
+    expect(mod).toBeUndefined();
+  });
+
+  it("returns undefined when the module lacks the factory", async () => {
+    const root = makeTree("agent", {
+      "package.json": JSON.stringify({ name: "@earendil-works/pi-coding-agent" }),
+      "dist/index.js": "",
+      "dist/extensions/codemode/tool.js": `
+        export const somethingElse = 1;
+      `,
+    });
+    const mod = await loadCodemodeModule(path.join(root, "dist", "index.js"));
+    expect(mod).toBeUndefined();
+  });
+});

package/src/codemode/loader.ts

@@ -0,0 +1,115 @@
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import path from "node:path";
+
+export interface CodemodeToolModule {
+  createCodemodeToolDefinition: (options?: Record<string, unknown>) => unknown;
+  codemodeSchema: unknown;
+}
+
+const AGENT_PACKAGE_NAME = "@earendil-works/pi-coding-agent";
+/** Candidate 1: relative to the package ROOT (the CLI-install walk-up). */
+const CODEMODE_MODULE_FROM_ROOT = path.join(
+  "dist",
+  "extensions",
+  "codemode",
+  "tool.js",
+);
+/** Candidate 2: relative to the `dist/` directory the package entry lives in. */
+const CODEMODE_MODULE_FROM_DIST = path.join(
+  "extensions",
+  "codemode",
+  "tool.js",
+);
+
+/**
+ * Walk up from `startDir` to the package root (the nearest ancestor holding a
+ * package.json) and return it when it is the pi-coding-agent package.
+ */
+export function findAgentPackageRoot(startDir: string): string | undefined {
+  let dir = startDir;
+  while (true) {
+    const pkgPath = path.join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        if (pkg.name === AGENT_PACKAGE_NAME) {
+          return dir;
+        }
+      } catch {
+        // Unreadable package.json — keep walking up.
+      }
+      // A package boundary without a matching name: stop (we are inside some
+      // other package's tree, not the agent's).
+      return undefined;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+}
+
+/**
+ * Candidate files for the codemode tool module, in preference order:
+ *
+ * 1. The running pi CLI's own install. `process.argv[1]` is the CLI entry
+ *    script (e.g. `…/pi-coding-agent/dist/bundle/cli.js`); walking up to the
+ *    package root finds the `dist` the CLI is actually running from. Pi loads
+ *    extensions with jiti, which shares the native module instance for `.js`
+ *    files, so when the CLI runs unbundled this is the very same module the
+ *    CLI's built-in codemode extension loaded — same schema object, same
+ *    executor.
+ * 2. Our own node_modules copy (resolved via `import.meta.resolve`). A
+ *    fallback for launchers whose argv[1] is not inside a pi-coding-agent
+ *    install. Older pi versions have no `dist/extensions/codemode` at all,
+ *    in which case the file does not exist and the candidate is skipped.
+ */
+export function resolveCodemodeModuleFiles(argv1?: string): string[] {
+  const candidates: string[] = [];
+  const entry = argv1 ?? process.argv[1];
+  if (typeof entry === "string" && entry.length > 0) {
+    let root: string | undefined;
+    try {
+      root = findAgentPackageRoot(path.dirname(realpathSync(entry)));
+    } catch {
+      root = undefined;
+    }
+    if (root) {
+      candidates.push(path.join(root, CODEMODE_MODULE_FROM_ROOT));
+    }
+  }
+  try {
+    // `import.meta.resolve` (the `import` condition) — the agent package's
+    // exports map has no `require` condition, so a CJS `require.resolve`
+    // would fail on newer pi versions.
+    const agentEntry = new URL(import.meta.resolve(AGENT_PACKAGE_NAME)).pathname;
+    // `agentEntry` is `…/pi-coding-agent/dist/index.js` — its directory IS the
+    // `dist` dir, so join the module path WITHOUT another `dist` segment.
+    candidates.push(path.join(path.dirname(agentEntry), CODEMODE_MODULE_FROM_DIST));
+  } catch {
+    // No local copy of the agent package — nothing else to try.
+  }
+  return candidates;
+}
+
+/**
+ * Load the codemode tool module from the running pi install (see
+ * {@link resolveCodemodeModuleFiles}). Returns `undefined` when the module
+ * cannot be found or loaded (e.g. a pi version without the codemode
+ * extension), so the caller can fall back to pi's native rendering.
+ */
+export async function loadCodemodeModule(
+  argv1?: string,
+): Promise<CodemodeToolModule | undefined> {
+  for (const file of resolveCodemodeModuleFiles(argv1)) {
+    if (!existsSync(file)) continue;
+    try {
+      const mod = await import(file);
+      if (typeof mod?.createCodemodeToolDefinition === "function") {
+        return mod as CodemodeToolModule;
+      }
+    } catch {
+      // Try the next candidate.
+    }
+  }
+  return undefined;
+}