@pi-archimedes/core 2.2.0 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/core",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "type": "module",
   "keywords": [
     "pi-package"
@@ -19,13 +19,16 @@
     "./overlay": "./src/overlay.ts",
     "./config": "./src/config.ts",
     "./settings-io": "./src/settings-io.ts",
-    "./profiler": "./src/profiler.ts"
+    "./profiler": "./src/profiler.ts",
+    "./tool-render": "./src/tool-render.ts"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.1.0",
     "@earendil-works/pi-tui": ">=0.1.0"
   },
   "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.84.2",
+    "@earendil-works/pi-tui": "^0.84.2",
     "typescript": "^6.0.0"
   },
   "pi": {

package/src/index.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI, ExtensionContext, ExtensionCommandContext, KeybindingsManager } from "@earendil-works/pi-coding-agent";
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import { TUI, type EditorTheme, type Component, type SettingItem } from "@earendil-works/pi-tui";
+import { type TUI, type EditorTheme, type Component, type SettingItem } from "@earendil-works/pi-tui";
 
 import { HephaestusEditor } from "./editor/index.js";
 

package/src/startup/index.ts

@@ -4,7 +4,7 @@ import { loadCoreConfig } from "../config.js";
 import { detectSection, parseSectionText, parseModelScope, formatColumns, buildItemWrapper, type ParsedSection, SECTION_KEYS } from "./sections.js";
 import { fetchLatestVersion, compareVersions } from "./version.js";
 import { stripAnsi } from "../text.js";
-import { Text, Spacer, Container, TUI, truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
+import { Text, Spacer, Container, type TUI, truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
 
 // Symbol keys (survive hot-reload)
 const LISTING_REF = Symbol.for("splashscreen:listingRef");

package/src/text.ts

@@ -29,7 +29,7 @@ export function clampLine(line: string, maxW: number): string {
 }
 
 /** Clamp an array of lines to maxW visible characters each. */
-export function clampLines(lines: string[], maxW: number): string[] {
+function clampLines(lines: string[], maxW: number): string[] {
   return lines.map((l) => clampLine(l, maxW));
 }
 

package/src/thinking/patch.test.ts

@@ -196,6 +196,54 @@ describe("patchThinkingRenderer", () => {
 		expect(MockClassV2.prototype[PATCH_VERSION_KEY]).toBe("2.0.0");
 	});
 
+	it("accepts a minified thinking-check variant (no whitespace around ===)", async () => {
+		const MockClass = function AssistantMessageComponent() {};
+		MockClass.prototype.updateContent = function updateContent() {
+			// Minified dist-chunk shape: no whitespace around ===, single quotes
+			const content = { type: "thinking" };
+			if (content.type==="thinking") {
+				this.markdownTheme.codeBlockIndent="";
+			}
+		};
+
+		vi.doMock("@earendil-works/pi-coding-agent", () => ({
+			AssistantMessageComponent: MockClass,
+			VERSION: "1.0.0",
+			highlightCode: vi.fn(),
+		}));
+
+		const patch = await importPatch();
+		patch(() => ({} as any));
+
+		// The minification-safe regex probe must accept the minified variant
+		expect(MockClass.prototype[PATCHED_KEY]).toBe(true);
+	});
+
+	it("rejects a negated thinking check", async () => {
+		const MockClass = function AssistantMessageComponent() {};
+		MockClass.prototype.updateContent = function updateContent() {
+			// pi 0.84.3's own minified chunk contains
+			// `thinkingContent.type!=="thinking"` (inner batch-loop break). A source whose
+			// ONLY thinking-relations are negations must NOT pass the probe.
+			const content = { type: "thinking" };
+			if (content.type!=="thinking") {
+				this.markdownTheme.codeBlockIndent="";
+			}
+		};
+
+		vi.doMock("@earendil-works/pi-coding-agent", () => ({
+			AssistantMessageComponent: MockClass,
+			VERSION: "1.0.0",
+			highlightCode: vi.fn(),
+		}));
+
+		const patch = await importPatch();
+		patch(() => ({} as any));
+
+		// PATCHED_KEY must NOT be set — the probe must not match `!==`
+		expect(MockClass.prototype[PATCHED_KEY]).toBeUndefined();
+	});
+
 	it("re-patches on same version to update getTheme closure", async () => {
 		const MockClass = function AssistantMessageComponent() {};
 		MockClass.prototype.updateContent = function updateContent() {

package/src/thinking/patch.ts

@@ -30,7 +30,13 @@ export function patchThinkingRenderer(getTheme: () => Theme): void {
   }
 
   const src = proto.updateContent.toString();
-  const hasThinkingCheck = src.includes('content.type === "thinking"');
+  // NOTE: pi ships the interactive TUI in a minified bundle chunk at runtime, so
+  // the source we see via .toString() can be `content.type==="thinking"` (no
+  // spaces) even where dist is readable. The probe below must therefore be
+  // minification-safe: a whitespace-tolerant regex rather than an exact
+  // substring. A bare `space === "thinking"` (or any other field) still does
+  // not match, as required.
+  const hasThinkingCheck = /content\.type\s*===\s*["']thinking["']/.test(src);
   const hasMarkdownTheme = src.includes("this.markdownTheme");
   if (!hasThinkingCheck || !hasMarkdownTheme) {
     console.warn(
@@ -55,9 +61,25 @@ export function patchThinkingRenderer(getTheme: () => Theme): void {
     }
   }
 
-  // Re-patch every time — /resume needs a fresh getTheme closure
-  (proto as any).updateContent = function (this: any, message: any): void {
+  // Re-patched every session_start — /resume needs a fresh getTheme closure.
+  //
+  // Shape: 0.84.3 pi native updateContent:
+  //   updateContent(message, isStreaming = this.isStreaming) {
+  //     this.lastMessage = message;
+  //     this.isStreaming = isStreaming;
+  //     this.contentContainer.clear();
+  //     ...
+  //     // batches consecutive "thinking" parts into thinkingBlocks
+  //     //   (skipping empties), i-- after the inner loop,
+  //     //   renders as ONE Markdown section of thinkingBlocks.join("\n\n")
+  //     // or ONE static Text label when hidden.
+  //     // stop-reason: const hasToolCalls = content.some(...);
+  //     //   this.hasToolCalls = hasToolCalls; (render() uses for OSC-133 zones)
+  //     //   stopReason === "length" → Spacer + "truncated" Text
+  //     //   else if (!hasToolCalls) { aborted / error branches }
+  (proto as any).updateContent = function (this: any, message: any, isStreaming?: boolean): void {
     this.lastMessage = message;
+    if (isStreaming !== undefined) this.isStreaming = isStreaming;
 
     this.markdownTheme.codeBlockIndent = "";
     this.contentContainer.clear();
@@ -105,11 +127,11 @@ export function patchThinkingRenderer(getTheme: () => Theme): void {
     // We must preserve it here, otherwise those transformers are silently
     // dropped when this patch replaces updateContent.
     //
-    // NOTE: the `transform` option was added to @earendil-works/pi-tui in
-    // 0.84.1. The repo's lockfile pins 0.78.0 whose types lack the field, so we
-    // extend the options type locally; at runtime the field is ignored by very
-    // old pi-tui and honored by 0.84.1+ (which is where Mermaid rendering and
-    // the bug both exist).
+    // NOTE: `createMarkdownTransform` is not exported from pi-coding-agent, so
+    // we inline an equivalent pipeline over `this.markdownTransformers`.
+    //
+    // The `transform` option was added to @earendil-works/pi-tui in 0.84.1.
+    // At runtime older pi-tui ignores the field, 0.84.1+ honors it.
     type MarkdownOptionsWithTransform = MarkdownOptions & {
       transform?: (markdown: string, availableWidth: number) => string;
     };
@@ -139,14 +161,27 @@ export function patchThinkingRenderer(getTheme: () => Theme): void {
         this.contentContainer.addChild(
           new Markdown(
             content.text.trim(),
-            1,
+            this.outputPad ?? 1,
             0,
             this.markdownTheme,
             undefined,
             { transform: transformFor("assistant") } as MarkdownOptionsWithTransform,
           ),
         );
-      } else if (content.type === "thinking" && content.thinking.trim()) {
+      } else if (content.type === "thinking") {
+        // Batch a consecutive run of thinking parts into one section
+        // (mirrors 0.84.3 pi native behaviour: thinkBlocks, i-- on the
+        // inner loop, early continue on zero-length runs).
+        const thinkBlocks: string[] = [];
+        for (; i < message.content.length; i++) {
+          const thinkingPart = message.content[i];
+          if (thinkingPart.type !== "thinking") break;
+          const trimmed = thinkingPart.thinking.trim();
+          if (trimmed) thinkBlocks.push(trimmed);
+        }
+        i--;
+        if (thinkBlocks.length === 0) continue;
+
         const hasVisibleContentAfter = message.content
           .slice(i + 1)
           .some(
@@ -156,16 +191,17 @@ export function patchThinkingRenderer(getTheme: () => Theme): void {
           );
 
         if (this.hideThinkingBlock) {
+          // One static label for the whole run when hidden.
           const t = ensureTheme();
           if (!t) continue;
           this.contentContainer.addChild(
-            new Text(t.italic(t.fg("thinkingText", this.hiddenThinkingLabel)), 1, 0),
+            new Text(t.italic(t.fg("thinkingText", this.hiddenThinkingLabel)), this.outputPad ?? 1, 0),
           );
           if (hasVisibleContentAfter) {
             this.contentContainer.addChild(new Spacer(1));
           }
         } else {
-          let thinkingContent = content.thinking.trim();
+          let thinkingContent = thinkBlocks.join("\n\n");
           if (!thinkingContent.startsWith(THINKING_LABEL)) {
             thinkingContent = `${THINKING_LABEL}\n\n${thinkingContent}`;
           }
@@ -175,7 +211,7 @@ export function patchThinkingRenderer(getTheme: () => Theme): void {
           this.contentContainer.addChild(
             new Markdown(
               thinkingContent,
-              1,
+              this.outputPad ?? 1,
               0,
               muted ?? this.markdownTheme,
               {
@@ -192,9 +228,19 @@ export function patchThinkingRenderer(getTheme: () => Theme): void {
       }
     }
 
-    // Aborted/error rendering.
+    // Stop-reason handling — 0.84.3 pi shape. `hasToolCalls` is required by
+    // the component's render() for OSC-133 prompt zones, so it must be set.
     const hasToolCalls = message.content.some((c: any) => c.type === "toolCall");
-    if (!hasToolCalls) {
+    this.hasToolCalls = hasToolCalls;
+
+    if (message.stopReason === "length") {
+      this.contentContainer.addChild(new Spacer(1));
+      const t = ensureTheme();
+      if (t)
+        this.contentContainer.addChild(
+          new Text(t.fg("error", "Response was truncated before completion."), this.outputPad ?? 1, 0),
+        );
+    } else if (!hasToolCalls) {
       if (message.stopReason === "aborted") {
         const abortMessage =
           message.errorMessage && message.errorMessage !== "Request was aborted"
@@ -202,21 +248,18 @@ export function patchThinkingRenderer(getTheme: () => Theme): void {
             : "Operation aborted";
         this.contentContainer.addChild(new Spacer(1));
         const t = ensureTheme();
-        if (t) this.contentContainer.addChild(new Text(t.fg("error", abortMessage), 1, 0));
+        if (t) this.contentContainer.addChild(new Text(t.fg("error", abortMessage), this.outputPad ?? 1, 0));
       } else if (message.stopReason === "error") {
         const errorMsg = message.errorMessage || "Unknown error";
         this.contentContainer.addChild(new Spacer(1));
         const t = ensureTheme();
         if (t) {
           this.contentContainer.addChild(
-            new Text(t.fg("error", `Error: ${errorMsg}`), 1, 0),
+            new Text(t.fg("error", `Error: ${errorMsg}`), this.outputPad ?? 1, 0),
           );
         }
       }
     }
-
-    // Bottom padding so next message has breathing room
-    this.contentContainer.addChild(new Spacer(1));
   };
 
   // Mark as patched with version for incompatibility detection

package/src/tool-render.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect } from "vitest";
+import {
+  renderToolHeader,
+  renderStatusLabel,
+  renderToolCallLine,
+  STATUS_GLYPH,
+  type ToolRenderTheme,
+} from "./tool-render.js";
+
+// Fake theme: wraps text in visible markers so assertions can verify tokens.
+const theme: ToolRenderTheme = {
+  fg: (token: string, text: string) => `[${token}:${text}]`,
+  bold: (text: string) => `**${text}**`,
+};
+
+describe("renderToolHeader", () => {
+  it("renders blue bold tool name + orange action", () => {
+    expect(renderToolHeader("mcp", "atlassian", theme)).toBe(
+      "[toolTitle:**mcp**] [accent:atlassian]",
+    );
+  });
+
+  it("renders the name only when action is empty", () => {
+    expect(renderToolHeader("todo", "", theme)).toBe("[toolTitle:**todo**]");
+    expect(renderToolHeader("todo", undefined, theme)).toBe(
+      "[toolTitle:**todo**]",
+    );
+  });
+});
+
+describe("renderStatusLabel", () => {
+  it("running: muted glyph + muted label", () => {
+    expect(renderStatusLabel("running", "2/4 completed", theme)).toBe(
+      "[muted:▸ ][muted:2/4 completed]",
+    );
+  });
+
+  it("success: green glyph + muted label", () => {
+    expect(renderStatusLabel("success", "done", theme)).toBe(
+      "[success:✓ ][muted:done]",
+    );
+  });
+
+  it("error: red glyph + muted label", () => {
+    expect(renderStatusLabel("error", "boom", theme)).toBe(
+      "[error:✗ ][muted:boom]",
+    );
+  });
+
+  it("exposes the glyph map", () => {
+    expect(STATUS_GLYPH).toEqual({ running: "▸", success: "✓", error: "✗" });
+  });
+});
+
+describe("renderToolCallLine", () => {
+  it("success: green glyph + green name + dim suffix", () => {
+    expect(renderToolCallLine("success", "read", ": /path", theme)).toBe(
+      "[success:✓ ][success:read][dim:: /path]",
+    );
+  });
+
+  it("error: red glyph + red name + dim suffix", () => {
+    expect(renderToolCallLine("error", "read", ": /missing", theme)).toBe(
+      "[error:✗ ][error:read][dim:: /missing]",
+    );
+  });
+
+  it("running: muted glyph + muted name", () => {
+    expect(renderToolCallLine("running", "grep", ": pattern | 2s", theme)).toBe(
+      "[muted:▸ ][muted:grep][dim:: pattern | 2s]",
+    );
+  });
+
+  it("omits the dim fragment when suffix is empty", () => {
+    expect(renderToolCallLine("success", "bash", "", theme)).toBe(
+      "[success:✓ ][success:bash]",
+    );
+  });
+});

package/src/tool-render.ts

@@ -0,0 +1,101 @@
+/**
+ * Shared tool-row rendering helpers.
+ *
+ * Archimedes tools (mcp, todo, …) render a consistent two-part row:
+ *
+ *   line 1 (header):  <toolName> (blue bold) + <action> (orange accent)
+ *   result line:      <glyph> <label>  — glyph reflects run status:
+ *                       ▸ running (muted) · ✓ success (green) · ✗ error (red)
+ *                     the label is muted so the glyph carries the colour.
+ *
+ * These helpers are pure (no TUI component imports) so they stay directly
+ * unit-testable and can be reused across packages. Callers wrap the returned
+ * string in whatever component they use (typically a pi-tui Text).
+ */
+
+import type { ThemeColor } from "@earendil-works/pi-coding-agent";
+
+/** Run status of a settled/in-flight tool row. */
+export type ToolStatus = "running" | "success" | "error";
+
+/** Glyph shown before the result label, keyed by status. */
+export const STATUS_GLYPH: Record<ToolStatus, string> = {
+  running: "▸",
+  success: "✓",
+  error: "✗",
+};
+
+/** Theme color token used to colour each status glyph. */
+const STATUS_TOKEN: Record<ToolStatus, ThemeColor> = {
+  running: "muted",
+  success: "success",
+  error: "error",
+};
+
+/**
+ * The subset of a pi Theme these helpers need. Typed with pi's ThemeColor so
+ * pi's real Theme is assignable (parameter contravariance: a fn requiring the
+ * wider string token would NOT accept a Theme whose fg only takes ThemeColor).
+ */
+export type ToolRenderTheme = {
+  fg: (token: ThemeColor, text: string) => string;
+  bold: (text: string) => string;
+};
+
+/**
+ * Render the tool header line:
+ *   <toolName> (toolTitle, bold) + " " + <action> (accent)
+ *
+ * When action is empty/undefined only the tool name is rendered.
+ */
+export function renderToolHeader(
+  toolName: string,
+  action: string | undefined,
+  theme: ToolRenderTheme,
+): string {
+  const name = theme.fg("toolTitle", theme.bold(toolName));
+  if (!action) return name;
+  return name + " " + theme.fg("accent", action);
+}
+
+/**
+ * Render a status result line:
+ *   <glyph> (status-coloured) + <label> (muted)
+ *
+ * e.g. "✓ atlassian_searchJiraIssuesUsingJql" or "▸ 2/4 completed".
+ */
+export function renderStatusLabel(
+  status: ToolStatus,
+  label: string,
+  theme: ToolRenderTheme,
+): string {
+  return (
+    theme.fg(STATUS_TOKEN[status], STATUS_GLYPH[status] + " ") +
+    theme.fg("muted", label)
+  );
+}
+
+/**
+ * Render a tool-call line with a status glyph, a status-coloured name, and an
+ * optional dim args/suffix fragment:
+ *
+ *   <glyph> (status-coloured) + <name> (status-coloured) + <suffix> (dim)
+ *
+ * e.g. "✓ read: /path/to/file" (green glyph+name, dim ": /path...") or
+ *      "▸ grep: pattern" (muted glyph+name while running).
+ *
+ * The name shares the glyph's colour (unlike renderStatusLabel, which mutes
+ * the label) so a completed call reads as a single green/red unit. The suffix
+ * is passed pre-formatted (e.g. ": args" or ": args | 2s") and rendered dim.
+ */
+export function renderToolCallLine(
+  status: ToolStatus,
+  name: string,
+  suffix: string,
+  theme: ToolRenderTheme,
+): string {
+  const token = STATUS_TOKEN[status];
+  const head =
+    theme.fg(token, STATUS_GLYPH[status] + " ") + theme.fg(token, name);
+  return suffix ? head + theme.fg("dim", suffix) : head;
+}