@ian-pascoe/pi-codemode 0.2.0 → 0.3.1

package/src/codemode-tool-rendering.ts

@@ -21,6 +21,7 @@ import {
 import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { formatCodeModePresentationData } from "./codemode-presentation-output.js";
+import { formatCodeModeDuration } from "./codemode-session-coordinator.js";
 import {
   CodeModeCancelParametersSchema,
   CodeModeExecuteParametersSchema,
@@ -116,13 +117,6 @@ function shortCodeModeSessionId(sessionId: string): string {
 /** Resolves one Session ID to the shortest unambiguous CodeMode Transcript label. */
 export type CodeModeSessionPrefixFormatter = (sessionId: string) => string;
 
-function formatCodeModeDuration(elapsedMs: number): string {
-  if (elapsedMs < 1_000) return `${elapsedMs}ms`;
-  if (elapsedMs < 60_000) return `${(elapsedMs / 1_000).toFixed(1)}s`;
-  const seconds = Math.floor(elapsedMs / 1_000);
-  return `${Math.floor(seconds / 60)}m ${String(seconds % 60).padStart(2, "0")}s`;
-}
-
 function pluralizedCodeModeCount(count: number, noun: string): string {
   return `${count} ${noun}${count === 1 ? "" : "s"}`;
 }
@@ -206,6 +200,47 @@ function highlightedCodeModeSource(source: string): string {
     .join("\n");
 }
 
+function truncateHighlightedCodeModeSourceLine(line: string, width: number): string {
+  if (visibleWidth(line) <= width) return line;
+  const prefix = sliceByColumn(line, 0, Math.max(0, width - 1), true);
+  return `${prefix}\u001b[22;23;24;25;27;28;29;39m…`;
+}
+
+class CodeModeCollapsedSourceComponent implements Component {
+  private readonly lines: readonly string[];
+
+  constructor(source: string) {
+    this.lines = highlightedCodeModeSource(source).split("\n");
+  }
+
+  render(width: number): string[] {
+    if (width <= 0) return [];
+    return this.lines.map((line) => truncateHighlightedCodeModeSourceLine(line, width));
+  }
+
+  invalidate(): void {}
+}
+
+class CodeModeCollapsedInlineSourceComponent implements Component {
+  constructor(
+    private readonly prefix: string,
+    private readonly source: string,
+    private readonly suffix: string,
+  ) {}
+
+  render(width: number): string[] {
+    if (width <= 0) return [];
+    const sourceWidth = width - visibleWidth(this.prefix) - visibleWidth(this.suffix);
+    if (visibleWidth(this.source) === 0 || sourceWidth <= 0)
+      return new Text(`${this.prefix.trimEnd()}${this.suffix}`, 0, 0).render(width);
+    return [
+      `${this.prefix}${truncateHighlightedCodeModeSourceLine(this.source, sourceWidth)}${this.suffix}`,
+    ];
+  }
+
+  invalidate(): void {}
+}
+
 function appendHighlightedCodeModeSource(container: Container, source: string): void {
   container.addChild(new Text(highlightedCodeModeSource(source), 0, 0));
 }
@@ -252,6 +287,7 @@ function renderCodeModeSummary(
   formatSessionPrefix: CodeModeSessionPrefixFormatter,
 ): string {
   const presentation = details.presentation;
+  const consoleEntries = details.result === "pending" ? undefined : details.console;
   const state = codeModeCellState(toolName, details);
   const status =
     details.result === "failed" && details.error.code === "eviction"
@@ -279,6 +315,9 @@ function renderCodeModeSummary(
       : undefined,
     details.result === "failed" ? theme.fg("muted", details.error.code) : undefined,
     details.result === "failed" ? boundedCodeModePreview(details.error.message, 64) : undefined,
+    consoleEntries === undefined
+      ? undefined
+      : theme.fg("muted", pluralizedCodeModeCount(consoleEntries.length, "console call")),
     state !== "running" && presentation !== undefined && presentation.nested_tool_count > 0
       ? theme.fg("muted", pluralizedCodeModeCount(presentation.nested_tool_count, "tool"))
       : undefined,
@@ -321,30 +360,27 @@ export function renderCodeModeToolCall(
   const oneLineSource = source !== undefined && !source.includes("\n") ? source : undefined;
   const expansionHint = `${keyText("app.tools.expand")} to expand`;
   const container = new Container();
-  container.addChild(
-    new Text(
-      [
-        theme.fg("toolTitle", theme.bold("CodeMode")),
-        theme.fg("accent", operation),
-        theme.fg("muted", sessionId === undefined ? "new" : formatSessionPrefix(sessionId)),
-        !expanded && oneLineSource !== undefined
-          ? highlightCode(oneLineSource, "typescript")[0]
-          : undefined,
-        !expanded && oneLineSource !== undefined
-          ? theme.fg("dim", `·  ${expansionHint}`)
-          : undefined,
-      ]
-        .filter((part): part is string => part !== undefined)
-        .join("  "),
-      0,
-      0,
-    ),
-  );
+  const header = [
+    theme.fg("toolTitle", theme.bold("CodeMode")),
+    theme.fg("accent", operation),
+    theme.fg("muted", sessionId === undefined ? "new" : formatSessionPrefix(sessionId)),
+  ].join("  ");
+  if (!expanded && oneLineSource !== undefined) {
+    container.addChild(
+      new CodeModeCollapsedInlineSourceComponent(
+        `${header}  `,
+        highlightCode(oneLineSource, "typescript")[0] ?? "",
+        `  ${theme.fg("dim", `·  ${expansionHint}`)}`,
+      ),
+    );
+  } else {
+    container.addChild(new Text(header, 0, 0));
+  }
   if (!expanded) {
     if (source === undefined || oneLineSource !== undefined) return container;
     const sourceLines = source.split("\n");
     const visibleSource = sourceLines.slice(0, CODEMODE_COLLAPSED_SCRIPT_LINES).join("\n");
-    appendHighlightedCodeModeSource(container, visibleSource);
+    container.addChild(new CodeModeCollapsedSourceComponent(visibleSource));
     const omittedLines = Math.max(0, sourceLines.length - CODEMODE_COLLAPSED_SCRIPT_LINES);
     const omitted =
       omittedLines === 0 ? "" : `… ${pluralizedCodeModeCount(omittedLines, "line")} omitted  ·  `;
@@ -414,6 +450,7 @@ export function renderCodeModeToolResult(
     return renderCodeModeFallback(result, options, theme, isError);
   }
   const details = result.details;
+  const consoleEntries = details.result === "pending" ? undefined : details.console;
   const summary = renderCodeModeSummary(details, toolName, theme, formatSessionPrefix);
   if (!options.expanded) {
     const hint = options.isPartial ? "" : `  ·  ${keyText("app.tools.expand")} to expand`;
@@ -462,6 +499,13 @@ export function renderCodeModeToolResult(
     }
   }
 
+  if (consoleEntries !== undefined) {
+    container.addChild(new Spacer(1));
+    container.addChild(new Text(theme.fg("muted", theme.bold("Console")), 0, 0));
+    const output = consoleEntries.map((entry) => `${entry.method}: ${entry.text}`).join("\n");
+    container.addChild(new Text(theme.fg("toolOutput", boundedCodeModeText(output, 2_000)), 0, 0));
+  }
+
   if (details.result === "success") {
     container.addChild(new Spacer(1));
     container.addChild(new Text(theme.fg("muted", theme.bold("Result")), 0, 0));

package/src/codemode-worker-protocol.ts

@@ -1,4 +1,5 @@
 import { Buffer } from "node:buffer";
+import { CODEMODE_CONSOLE_METHODS, type CodeModeConsoleEntry } from "./codemode-console-output.ts";
 
 /** Maximum UTF-8 bytes in one CodeMode worker protocol line, excluding its newline. */
 export const CODEMODE_WORKER_MESSAGE_LIMIT_BYTES = 8 * 1024 * 1024;
@@ -76,6 +77,7 @@ export type CodeModeWorkerResponse =
       readonly sessionId: string;
       readonly cellId: string;
       readonly resultJson?: string;
+      readonly console?: readonly CodeModeConsoleEntry[];
     }
   | {
       readonly version: 1;
@@ -83,6 +85,7 @@ export type CodeModeWorkerResponse =
       readonly sessionId: string;
       readonly cellId: string;
       readonly error: { readonly code: CodeModeWorkerCellErrorCode; readonly message: string };
+      readonly console?: readonly CodeModeConsoleEntry[];
     }
   | {
       readonly version: 1;
@@ -132,19 +135,61 @@ function hasString(values: readonly string[], candidate: string): boolean {
 function hasExactKeys(value: CodeModeProtocolObject, expected: readonly string[]): boolean {
   const keys = objectKeys(value);
   if (keys.length !== expected.length) return false;
-  for (let expectedIndex = 0; expectedIndex < expected.length; expectedIndex += 1) {
-    const expectedKey = expected[expectedIndex];
-    if (expectedKey === undefined) return false;
-    let found = false;
-    for (let keyIndex = 0; keyIndex < keys.length; keyIndex += 1) {
-      if (keys[keyIndex] === expectedKey) {
-        found = true;
-        break;
+  return expected.every((expectedKey) => expectedKey !== undefined && keys.includes(expectedKey));
+}
+
+function hasDuplicateJsonObjectKeys(message: string): boolean {
+  const objectKeysByDepth: (string[] | undefined)[] = [];
+  for (let index = 0; index < message.length; index += 1) {
+    const character = message[index];
+    if (character === "{") {
+      objectKeysByDepth.push([]);
+      continue;
+    }
+    if (character === "[") {
+      objectKeysByDepth.push(undefined);
+      continue;
+    }
+    if (character === "}" || character === "]") {
+      objectKeysByDepth.pop();
+      continue;
+    }
+    if (character !== '"') continue;
+
+    let endIndex = index + 1;
+    for (; endIndex < message.length; endIndex += 1) {
+      if (message[endIndex] === "\\") {
+        endIndex += 1;
+        continue;
       }
+      if (message[endIndex] === '"') break;
     }
-    if (!found) return false;
+    if (endIndex >= message.length) return false;
+    let nextIndex = endIndex + 1;
+    while (
+      message[nextIndex] === " " ||
+      message[nextIndex] === "\n" ||
+      message[nextIndex] === "\r" ||
+      message[nextIndex] === "\t"
+    ) {
+      nextIndex += 1;
+    }
+    const keys = objectKeysByDepth[objectKeysByDepth.length - 1];
+    if (message[nextIndex] === ":" && keys !== undefined) {
+      try {
+        // SAFETY: This slice is one syntactically bounded JSON string token; the string refinement below rejects every other JSON value.
+        const key = jsonParse(message.slice(index, endIndex + 1)) as CodeModeProtocolValue;
+        if (isString(key)) {
+          if (hasString(keys, key)) return true;
+          keys.push(key);
+        }
+      } catch {
+        return false;
+      }
+    }
+    index = endIndex;
   }
-  return true;
+  return false;
 }
 
 function parseProtocolJson(
@@ -158,6 +203,9 @@ function parseProtocolJson(
   if (Buffer.byteLength(message, "utf8") > CODEMODE_WORKER_MESSAGE_LIMIT_BYTES) {
     return { ok: false, message: `CodeMode worker ${subject} exceeds 8 MiB` };
   }
+  if (hasDuplicateJsonObjectKeys(message)) {
+    return { ok: false, message: `CodeMode worker ${subject} contains duplicate object keys` };
+  }
   try {
     // SAFETY: Successful JSON.parse output is exactly the recursive JSON representation modeled by CodeModeProtocolValue.
     return { ok: true, value: jsonParse(message) as CodeModeProtocolValue };
@@ -308,6 +356,30 @@ function parseWorkerError(
   return { code: value.code, message: value.message };
 }
 
+function parseConsoleOutput(
+  value: CodeModeProtocolSlot,
+): readonly CodeModeConsoleEntry[] | undefined {
+  if (!arrayIsArray(value) || value.length === 0) return undefined;
+  const entries: CodeModeConsoleEntry[] = [];
+  for (const candidate of value) {
+    if (
+      !isRecord(candidate) ||
+      !hasExactKeys(candidate, ["method", "text"]) ||
+      !isString(candidate.method) ||
+      !hasString(CODEMODE_CONSOLE_METHODS, candidate.method) ||
+      !isString(candidate.text)
+    ) {
+      return undefined;
+    }
+    entries.push({
+      // SAFETY: The literal-membership check above refines the protocol string to a supported Console method.
+      method: candidate.method as CodeModeConsoleEntry["method"],
+      text: candidate.text,
+    });
+  }
+  return entries;
+}
+
 function parseToolBatchResponse(
   decoded: CodeModeProtocolObject,
 ): CodeModeWorkerResponse | undefined {
@@ -401,43 +473,58 @@ export function parseCodeModeWorkerResponse(
   }
   if (
     decoded.type === "cell-result" &&
-    hasExactKeys(
-      decoded,
-      decoded.resultJson === undefined
-        ? ["cellId", "sessionId", "type", "version"]
-        : ["cellId", "resultJson", "sessionId", "type", "version"],
-    ) &&
     isNonEmptyString(decoded.cellId) &&
     (decoded.resultJson === undefined || isString(decoded.resultJson))
   ) {
+    const expectedKeys = ["cellId", "sessionId", "type", "version"];
+    if (decoded.resultJson !== undefined) expectedKeys.push("resultJson");
+    if (decoded.console !== undefined) expectedKeys.push("console");
+    if (!hasExactKeys(decoded, expectedKeys)) {
+      return { ok: false, message: "CodeMode worker response has an invalid protocol shape" };
+    }
+    const consoleEntries =
+      decoded.console === undefined ? undefined : parseConsoleOutput(decoded.console);
+    if (decoded.console !== undefined && consoleEntries === undefined) {
+      return { ok: false, message: "CodeMode worker response has an invalid protocol shape" };
+    }
     const value = {
       version: CODEMODE_WORKER_PROTOCOL_VERSION,
       type: "cell-result",
       sessionId: decoded.sessionId,
       cellId: decoded.cellId,
     } as const;
-    return decoded.resultJson === undefined
-      ? { ok: true, value }
-      : { ok: true, value: { ...value, resultJson: decoded.resultJson } };
+    const resultValue =
+      decoded.resultJson === undefined ? value : { ...value, resultJson: decoded.resultJson };
+    return consoleEntries === undefined
+      ? { ok: true, value: resultValue }
+      : { ok: true, value: { ...resultValue, console: consoleEntries } };
   }
-  if (
-    decoded.type === "cell-error" &&
-    hasExactKeys(decoded, ["cellId", "error", "sessionId", "type", "version"]) &&
-    isNonEmptyString(decoded.cellId)
-  ) {
+  if (decoded.type === "cell-error" && isNonEmptyString(decoded.cellId)) {
+    const expectedKeys = ["cellId", "error", "sessionId", "type", "version"];
+    if (decoded.console !== undefined) expectedKeys.push("console");
+    if (!hasExactKeys(decoded, expectedKeys)) {
+      return { ok: false, message: "CodeMode worker response has an invalid protocol shape" };
+    }
     const error = parseWorkerError(decoded.error);
-    if (error !== undefined && ["script", "serialization", "runtime"].includes(error.code)) {
+    const consoleEntries =
+      decoded.console === undefined ? undefined : parseConsoleOutput(decoded.console);
+    if (
+      error !== undefined &&
+      ["script", "serialization", "runtime"].includes(error.code) &&
+      (decoded.console === undefined || consoleEntries !== undefined)
+    ) {
       // SAFETY: The literal-membership check above refines the protocol string to the closed worker error code union.
       const code = error.code as CodeModeWorkerCellErrorCode;
+      const value = {
+        version: CODEMODE_WORKER_PROTOCOL_VERSION,
+        type: "cell-error",
+        sessionId: decoded.sessionId,
+        cellId: decoded.cellId,
+        error: { code, message: error.message },
+      } as const;
       return {
         ok: true,
-        value: {
-          version: CODEMODE_WORKER_PROTOCOL_VERSION,
-          type: "cell-error",
-          sessionId: decoded.sessionId,
-          cellId: decoded.cellId,
-          error: { code, message: error.message },
-        },
+        value: consoleEntries === undefined ? value : { ...value, console: consoleEntries },
       };
     }
   }
@@ -456,7 +543,28 @@ export function serializeCodeModeWorkerRequest(
 
 /** Serializes one worker response, replacing oversized Cell output with a bounded error. */
 export function serializeCodeModeWorkerResponse(response: CodeModeWorkerResponse): string {
-  const message = jsonStringify(response);
+  let message: string;
+  if (response.type === "cell-result" && response.console?.length === 0) {
+    const responseBase = {
+      version: response.version,
+      type: response.type,
+      sessionId: response.sessionId,
+      cellId: response.cellId,
+    } as const;
+    message = jsonStringify(
+      response.resultJson === undefined
+        ? responseBase
+        : { ...responseBase, resultJson: response.resultJson },
+    );
+  } else if (response.type === "cell-error" && response.console?.length === 0) {
+    message = jsonStringify({
+      version: response.version,
+      type: response.type,
+      sessionId: response.sessionId,
+      cellId: response.cellId,
+      error: response.error,
+    });
+  } else message = jsonStringify(response);
   if (Buffer.byteLength(message, "utf8") <= CODEMODE_WORKER_MESSAGE_LIMIT_BYTES) return message;
   if (
     response.type === "cell-result" ||