@selesai/code 0.10.2 → 0.12.0

package/dist/extensions/pi-tool-display/tests/diff-renderer-wrap.test.ts

@@ -0,0 +1,169 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { Box, type Component } from "@earendil-works/pi-tui";
+import { renderEditDiffResult } from "../src/diff-renderer.ts";
+
+const theme = {
+	fg: (_color: string, text: string): string => text,
+	bold: (text: string): string => text,
+};
+
+function stripAnsi(text: string): string {
+	return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+function renderInsideToolBox(component: Component, width: number): string[] {
+	const box = new Box(1, 1);
+	box.addChild(component);
+	return box.render(width).map(stripAnsi);
+}
+
+function extractDisplayedLineNumber(line: string): string | null {
+	const match = line.match(/^\s*(?:[▌+\-]?\s*)(\d*)\s+│/);
+	if (!match) {
+		return null;
+	}
+	return match[1] ?? "";
+}
+
+function countDisplayedLineNumber(lines: string[], lineNumber: string): number {
+	return lines.reduce((count, line) => count + (extractDisplayedLineNumber(line) === lineNumber ? 1 : 0), 0);
+}
+
+function extractUnifiedDiffRows(lines: string[]): string[] {
+	return lines.filter((line) => extractDisplayedLineNumber(line) !== null);
+}
+
+function splitRenderedRow(line: string, width: number): { left: string; right: string } {
+	const separatorWidth = 3;
+	const leftWidth = Math.floor((width - separatorWidth) / 2);
+	return {
+		left: line.slice(0, leftWidth),
+		right: line.slice(leftWidth + separatorWidth),
+	};
+}
+
+function extractSplitDiffRows(lines: string[], width: number): Array<{ left: string; right: string }> {
+	return lines
+		.map((line) => splitRenderedRow(line, width))
+		.filter(({ left, right }) => extractDisplayedLineNumber(left) !== null || extractDisplayedLineNumber(right) !== null);
+}
+
+function extractCellContent(cell: string): string {
+	const dividerIndex = cell.indexOf("│ ");
+	if (dividerIndex === -1) {
+		return "";
+	}
+	return cell.slice(dividerIndex + 2).trimEnd();
+}
+
+test("unified diff wrapped continuation rows should not repeat line numbers", () => {
+	const width = 60;
+	const component = renderEditDiffResult(
+		{
+			diff: "--- a/demo.txt\n+++ b/demo.txt\n@@ -1 +1 @@\n-this is a very long line that exceeds the available width and will wrap to multiple rows\n",
+		},
+		{ expanded: false, filePath: "demo.txt" },
+		{
+			diffViewMode: "unified",
+			diffSplitMinWidth: 80,
+			diffCollapsedLines: 24,
+			diffWordWrap: true,
+		} as any,
+		theme,
+		"",
+	);
+
+	const lines = renderInsideToolBox(component, width);
+
+	assert.strictEqual(
+		countDisplayedLineNumber(lines, "1"),
+		1,
+		`Expected wrapped unified rows to show line number 1 only once.\n${lines.join("\n")}`,
+	);
+});
+
+test("split diff falls back to unified with the same continuation numbering behavior", () => {
+	const width = 50;
+	const component = renderEditDiffResult(
+		{
+			diff: "--- a/demo.txt\n+++ b/demo.txt\n@@ -1 +1 @@\n-this is a very long line that will definitely need to wrap when rendered in narrow panes\n",
+		},
+		{ expanded: false, filePath: "demo.txt" },
+		{
+			diffViewMode: "split",
+			diffSplitMinWidth: 80,
+			diffCollapsedLines: 24,
+			diffWordWrap: true,
+		} as any,
+		theme,
+		"",
+	);
+
+	const lines = renderInsideToolBox(component, width);
+
+	assert.strictEqual(
+		countDisplayedLineNumber(lines, "1"),
+		1,
+		`Expected split fallback rows to show line number 1 only once.\n${lines.join("\n")}`,
+	);
+});
+
+test("multi-line unified diff keeps continuation rows blank while preserving logical line numbers", () => {
+	const width = 50;
+	const component = renderEditDiffResult(
+		{
+			diff: "--- a/demo.txt\n+++ b/demo.txt\n@@ -1,2 +1,2 @@\n-first very long line that will definitely need to wrap for sure\n-second very long line also wrapping because it is too long\n+first replacement also very long and needs to wrap\n+second replacement line that wraps too\n",
+		},
+		{ expanded: false, filePath: "demo.txt" },
+		{
+			diffViewMode: "unified",
+			diffSplitMinWidth: 80,
+			diffCollapsedLines: 24,
+			diffWordWrap: true,
+		} as any,
+		theme,
+		"",
+	);
+
+	const lines = renderInsideToolBox(component, width);
+	const diffRows = extractUnifiedDiffRows(lines);
+	const displayedNumbers = diffRows.map(extractDisplayedLineNumber);
+
+	assert.ok(diffRows.length > 4, `Expected wrapped unified output to span multiple visual rows.\n${lines.join("\n")}`);
+	assert.strictEqual(countDisplayedLineNumber(diffRows, "1"), 2, `Expected logical line 1 once per side.\n${diffRows.join("\n")}`);
+	assert.strictEqual(countDisplayedLineNumber(diffRows, "2"), 2, `Expected logical line 2 once per side.\n${diffRows.join("\n")}`);
+	assert.ok(displayedNumbers.includes(""), `Expected at least one continuation row with a blank line number.\n${diffRows.join("\n")}`);
+});
+
+test("split diff keeps wrapped rows vertically aligned with blank placeholder cells", () => {
+	const width = 120;
+	const component = renderEditDiffResult(
+		{
+			diff: "--- a/demo.txt\n+++ b/demo.txt\n@@ -1 +1 @@\n-this is a very long original line that will wrap across multiple visual rows in split mode\n+short replacement\n",
+		},
+		{ expanded: false, filePath: "demo.txt" },
+		{
+			diffViewMode: "split",
+			diffSplitMinWidth: 80,
+			diffCollapsedLines: 24,
+			diffWordWrap: true,
+		} as any,
+		theme,
+		"",
+	);
+
+	const lines = renderInsideToolBox(component, width);
+	const diffRows = extractSplitDiffRows(lines, width);
+	const firstRow = diffRows[0];
+	const secondRow = diffRows[1];
+
+	assert.ok(firstRow, `Expected at least one split diff row.\n${lines.join("\n")}`);
+	assert.ok(secondRow, `Expected a continuation row for the wrapped left side.\n${lines.join("\n")}`);
+	assert.strictEqual(extractDisplayedLineNumber(firstRow.left), "1", `Expected first left cell to show line number 1.\n${firstRow.left}`);
+	assert.strictEqual(extractDisplayedLineNumber(firstRow.right), "1", `Expected first right cell to show line number 1.\n${firstRow.right}`);
+	assert.strictEqual(extractDisplayedLineNumber(secondRow.left), "", `Expected wrapped left continuation row to blank its line number.\n${secondRow.left}`);
+	assert.strictEqual(extractCellContent(secondRow.left).length > 0, true, `Expected wrapped left continuation content to remain visible.\n${secondRow.left}`);
+	assert.strictEqual(extractDisplayedLineNumber(secondRow.right), "", `Expected blank placeholder row on the unwrapped right side.\n${secondRow.right}`);
+	assert.strictEqual(extractCellContent(secondRow.right), "", `Expected blank placeholder cell content on the unwrapped right side.\n${secondRow.right}`);
+});

package/dist/extensions/pi-tool-display/tests/index-integration.test.ts

@@ -0,0 +1,354 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+} from "@earendil-works/pi-coding-agent";
+import toolDisplayExtension from "../src/index.ts";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+interface CapturedHandler {
+  event: string;
+  handler: (...args: unknown[]) => unknown;
+}
+
+interface CapturedCommand {
+  name: string;
+  description?: string;
+  handler?: (...args: unknown[]) => unknown;
+}
+
+function createApiStub(
+  overrides: Partial<{
+    registerTool: (tool: unknown) => void;
+    registerCommand: (name: string, cmd: unknown) => void;
+    on: (event: string, handler: (...args: unknown[]) => unknown) => void;
+    getAllTools: () => unknown[];
+    getCommands: () => Array<{ name: string }>;
+  }> = {},
+): {
+  api: ExtensionAPI;
+  capturedTools: Array<{ name: string } & Record<string, unknown>>;
+  capturedCommands: CapturedCommand[];
+  capturedHandlers: CapturedHandler[];
+} {
+  const capturedTools: Array<{ name: string } & Record<string, unknown>> = [];
+  const capturedCommands: CapturedCommand[] = [];
+  const capturedHandlers: CapturedHandler[] = [];
+
+  const api = {
+    registerTool(tool: unknown): void {
+      capturedTools.push(tool as { name: string } & Record<string, unknown>);
+      overrides.registerTool?.(tool);
+    },
+    registerCommand(name: string, cmd: unknown): void {
+      capturedCommands.push({ name, ...(cmd as object) } as CapturedCommand);
+      overrides.registerCommand?.(name, cmd);
+    },
+    on(event: string, handler: (...args: unknown[]) => unknown): void {
+      capturedHandlers.push({ event, handler });
+      overrides.on?.(event, handler);
+    },
+    getAllTools(): unknown[] {
+      return overrides.getAllTools?.() ?? [];
+    },
+    getCommands(): Array<{ name: string }> {
+      return overrides.getCommands?.() ?? [];
+    },
+  } as unknown as ExtensionAPI;
+
+  return { api, capturedTools, capturedCommands, capturedHandlers };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+test("entry point registers expected lifecycle handlers", () => {
+  const { api, capturedHandlers } = createApiStub();
+  toolDisplayExtension(api);
+
+  const eventNames = capturedHandlers.map((h) => h.event);
+  // Thinking-label handlers
+  assert.ok(eventNames.includes("message_update"), "message_update handler registered");
+  assert.ok(eventNames.includes("message_end"), "message_end handler registered");
+  assert.ok(eventNames.includes("context"), "context handler registered");
+  // Lifecycle handlers from index.ts directly
+  assert.ok(eventNames.includes("session_start"), "session_start handler registered");
+  assert.ok(eventNames.includes("before_agent_start"), "before_agent_start handler registered");
+  // User-message-box lifecycle handlers
+  const sessionStartCount = eventNames.filter((e) => e === "session_start").length;
+  assert.ok(sessionStartCount >= 1, "at least one session_start handler registered");
+  const beforeAgentStartCount = eventNames.filter((e) => e === "before_agent_start").length;
+  assert.ok(beforeAgentStartCount >= 1, "at least one before_agent_start handler registered");
+});
+
+test("entry point registers tool-display command", () => {
+  const { api, capturedCommands } = createApiStub();
+  toolDisplayExtension(api);
+
+  const cmdNames = capturedCommands.map((c) => c.name);
+  assert.ok(cmdNames.includes("tool-display"), "tool-display command registered");
+});
+
+test("entry point registers built-in tool overrides", () => {
+  const { api, capturedTools } = createApiStub();
+  toolDisplayExtension(api);
+
+  const toolNames = capturedTools.map((t) => t.name);
+  // find, ls, write are registered immediately; read/grep/edit/bash are deferred
+  assert.ok(toolNames.includes("find"), "find tool override registered");
+  assert.ok(toolNames.includes("ls"), "ls tool override registered");
+  assert.ok(toolNames.includes("write"), "write tool override registered");
+
+  // Disabled tools (if config disables them) would not appear; the default
+  // config enables all, so we expect at least these 3 immediately.
+  assert.ok(toolNames.length >= 3, "at least 3 tool overrides registered immediately");
+});
+
+test("session_start handler refreshes capabilities and notifies pending errors", async () => {
+  const { api, capturedHandlers } = createApiStub();
+  toolDisplayExtension(api);
+
+  const sessionHandler = capturedHandlers.find((h) => h.event === "session_start")?.handler;
+  assert.ok(sessionHandler, "session_start handler captured");
+
+  const ctx = {
+    ui: {
+      theme: { fg: (_c: string, t: string) => t },
+      notify: (_msg: string, _level: string) => { /* no-op */ },
+    },
+  };
+
+  // Should not throw
+  await assert.doesNotReject(async () => sessionHandler({}, ctx));
+});
+
+test("before_agent_start handler refreshes capabilities without crashing", async () => {
+  const { api, capturedHandlers } = createApiStub();
+  toolDisplayExtension(api);
+
+  const beforeHandler = capturedHandlers.find((h) => h.event === "before_agent_start")?.handler;
+  assert.ok(beforeHandler, "before_agent_start handler captured");
+
+  // Should not throw
+  await assert.doesNotReject(async () => beforeHandler());
+});
+
+test("multiple calls to toolDisplayExtension are idempotent", () => {
+  const { api, capturedTools, capturedCommands, capturedHandlers } = createApiStub();
+
+  // Call twice
+  toolDisplayExtension(api);
+  toolDisplayExtension(api);
+
+  // Second call should not throw. Tools may be registered again (that's up
+  // to the extension loader to deduplicate), but the extension itself must
+  // not crash.
+  const toolNames = capturedTools.map((t) => t.name);
+  assert.ok(toolNames.filter((n) => n === "find").length >= 1, "find registered at least once");
+  assert.ok(toolNames.filter((n) => n === "ls").length >= 1, "ls registered at least once");
+  assert.ok(toolNames.filter((n) => n === "write").length >= 1, "write registered at least once");
+
+  const cmdNames = capturedCommands.map((c) => c.name);
+  assert.ok(cmdNames.filter((n) => n === "tool-display").length >= 1, "command registered at least once");
+});
+
+test("entry point tolerates empty getAllTools and getCommands results", () => {
+  // Stub that returns empty arrays for discovery methods
+  const { api } = createApiStub({
+    getAllTools: () => [],
+    getCommands: () => [],
+  });
+
+  assert.doesNotThrow(() => toolDisplayExtension(api));
+});
+
+test("entry point tolerates tools with existing owners in getAllTools", () => {
+  const { api } = createApiStub({
+    getAllTools: () => [
+      { name: "read", sourceInfo: { source: "local", path: "/ext/read.ts" } },
+      { name: "edit", sourceInfo: { source: "local", path: "/ext/edit.ts" } },
+      { name: "grep", sourceInfo: { source: "local", path: "/ext/grep.ts" } },
+    ],
+    getCommands: () => [{ name: "custom" }],
+  });
+
+  assert.doesNotThrow(() => toolDisplayExtension(api));
+});
+
+test("graceful degradation: extension throws when registerCommand is missing", () => {
+  // Simulate a minimal stub missing registerCommand
+  const minimalApi = {
+    registerTool(): void { /* no-op */ },
+    on(): void { /* no-op */ },
+    getAllTools(): unknown[] { return []; },
+    getCommands(): Array<{ name: string }> { return []; },
+  } as unknown as ExtensionAPI;
+
+  // registerToolDisplayCommand calls pi.registerCommand directly, so this
+  // is expected to throw in a peer-dep mismatch scenario.
+  assert.throws(
+    () => toolDisplayExtension(minimalApi),
+    /registerCommand/i,
+    "missing registerCommand should propagate",
+  );
+});
+
+test("graceful degradation: extension throws when on is missing", () => {
+  const minimalApi = {
+    registerTool(): void { /* no-op */ },
+    registerCommand(): void { /* no-op */ },
+    getAllTools(): unknown[] { return []; },
+    getCommands(): Array<{ name: string }> { return []; },
+  } as unknown as ExtensionAPI;
+
+  // registerNativeUserMessageBox calls pi.on, so this should throw when on is missing
+  assert.throws(
+    () => toolDisplayExtension(minimalApi),
+    /pi\.on is not a function|on is not a function/i,
+    "missing on should propagate",
+  );
+});
+
+test("lifecycle events fire in expected order during a session lifecycle", async () => {
+  // Simulate the sequence: setup → before_agent_start → session_start
+  const { api, capturedHandlers } = createApiStub();
+
+  toolDisplayExtension(api);
+
+  // Manually invoke handlers in expected lifecycle order
+  const beforeHandler = capturedHandlers.find((h) => h.event === "before_agent_start")?.handler;
+  const sessionHandler = capturedHandlers.find((h) => h.event === "session_start")?.handler;
+  const messageUpdateHandler = capturedHandlers.find((h) => h.event === "message_update")?.handler;
+  const messageEndHandler = capturedHandlers.find((h) => h.event === "message_end")?.handler;
+  const contextHandler = capturedHandlers.find((h) => h.event === "context")?.handler;
+
+  assert.ok(beforeHandler, "before_agent_start handler found");
+  assert.ok(sessionHandler, "session_start handler found");
+
+  // Simulate a session lifecycle
+  await beforeHandler();
+  await sessionHandler(
+    {},
+    { ui: { theme: { fg: (_c: string, t: string) => t }, notify: () => {} } },
+  );
+
+  // Simulate message lifecycle for thinking labels
+  if (messageUpdateHandler) {
+    await messageUpdateHandler(
+      {
+        message: {
+          role: "assistant",
+          api: "anthropic-messages",
+          content: [{ type: "thinking", thinking: "test" }],
+        },
+      },
+      { ui: { theme: { fg: (_c: string, t: string) => `[${_c}]${t}` } } },
+    );
+  }
+
+  if (messageEndHandler) {
+    await messageEndHandler(
+      {
+        message: {
+          role: "assistant",
+          api: "openai-chat",
+          content: [{ type: "thinking", thinking: "done" }],
+        },
+      },
+      {},
+    );
+  }
+
+  if (contextHandler) {
+    await contextHandler(
+      {
+        messages: [
+          {
+            role: "assistant",
+            content: [{ type: "thinking", thinking: "\x1b[31mThinking: \x1b[0mcontext" }],
+          },
+        ],
+      },
+      {},
+    );
+  }
+
+  // All handlers executed without throwing - this is the main assertion
+  assert.ok(true, "lifecycle handlers completed without error");
+});
+
+test("session_start handler tolerates missing ctx.ui", async () => {
+  const { api, capturedHandlers } = createApiStub();
+  toolDisplayExtension(api);
+
+  const sessionHandler = capturedHandlers.find((h) => h.event === "session_start")?.handler;
+  assert.ok(sessionHandler);
+
+  // ctx with no ui (edge case from older pi versions)
+  await assert.doesNotReject(async () => sessionHandler({}, {}));
+});
+
+test("before_agent_start handler tolerates being called multiple times", async () => {
+  const { api, capturedHandlers } = createApiStub();
+  toolDisplayExtension(api);
+
+  const beforeHandler = capturedHandlers.find((h) => h.event === "before_agent_start")?.handler;
+  assert.ok(beforeHandler);
+
+  await assert.doesNotReject(async () => beforeHandler());
+  await assert.doesNotReject(async () => beforeHandler());
+  await assert.doesNotReject(async () => beforeHandler());
+});
+
+test("session_start handler tolerates being called multiple times", async () => {
+  const { api, capturedHandlers } = createApiStub();
+  toolDisplayExtension(api);
+
+  const sessionHandler = capturedHandlers.find((h) => h.event === "session_start")?.handler;
+  assert.ok(sessionHandler);
+
+  const ctx = { ui: { theme: {}, notify: () => {} } };
+  await assert.doesNotReject(async () => sessionHandler({}, ctx));
+  await assert.doesNotReject(async () => sessionHandler({}, ctx));
+  await assert.doesNotReject(async () => sessionHandler({}, ctx));
+});
+
+test("overridden tools include renderCall and renderResult functions", () => {
+  const { api, capturedTools } = createApiStub();
+  toolDisplayExtension(api);
+
+  for (const tool of capturedTools) {
+    assert.ok(
+      typeof tool.renderCall === "function",
+      `${tool.name} has renderCall`,
+    );
+    assert.ok(
+      typeof tool.renderResult === "function",
+      `${tool.name} has renderResult`,
+    );
+  }
+});
+
+test("overridden tools preserve promptSnippet and promptGuidelines from built-ins", () => {
+  const { api, capturedTools } = createApiStub();
+  toolDisplayExtension(api);
+
+  const byName = new Map(capturedTools.map((t) => [t.name, t]));
+
+  // read (deferred) won't be registered immediately; it's deferred
+  // So we only check tools registered immediately
+  for (const name of ["find", "ls", "write"] as const) {
+    const tool = byName.get(name);
+    assert.ok(tool, `${name} is registered`);
+    // promptSnippet should be a non-empty string or undefined
+    // (built-in tools may or may not have promptSnippet)
+    if (tool.promptSnippet !== undefined) {
+      assert.equal(typeof tool.promptSnippet, "string");
+    }
+  }
+});

package/dist/extensions/pi-tool-display/tests/pending-diff-preview.test.ts

@@ -0,0 +1,79 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import {
+  buildPendingEditPreviewData,
+  buildPendingWritePreviewData,
+} from "../src/pending-diff-preview.ts";
+
+function withTempWorkspace(name: string, run: (workspace: string) => void): void {
+  const workspace = mkdtempSync(join(tmpdir(), name));
+  try {
+    run(workspace);
+  } finally {
+    rmSync(workspace, { recursive: true, force: true });
+  }
+}
+
+test("pending write preview compares existing safe workspace files", () => {
+  withTempWorkspace("pi-tool-display-write-preview-", (workspace) => {
+    writeFileSync(join(workspace, "sample.txt"), "before\n", "utf8");
+
+    const preview = buildPendingWritePreviewData(
+      { path: "sample.txt", content: "after\n" },
+      workspace,
+    );
+
+    assert.equal(preview?.fileExistedBeforeWrite, true);
+    assert.equal(preview?.previousContent, "before\n");
+    assert.equal(preview?.nextContent, "after\n");
+    assert.equal(preview?.notice, undefined);
+  });
+});
+
+test("pending preview skips direct reads outside the workspace", () => {
+  withTempWorkspace("pi-tool-display-boundary-", (workspace) => {
+    const outside = mkdtempSync(join(tmpdir(), "pi-tool-display-outside-"));
+    try {
+      const outsideFile = join(outside, "secret.txt");
+      writeFileSync(outsideFile, "secret\n", "utf8");
+
+      const editPreview = buildPendingEditPreviewData(
+        { path: outsideFile, oldText: "secret", newText: "safe" },
+        workspace,
+      );
+      const writePreview = buildPendingWritePreviewData(
+        { path: outsideFile, content: "replacement\n" },
+        workspace,
+      );
+
+      assert.equal(editPreview?.previousContent, undefined);
+      assert.equal(editPreview?.nextContent, undefined);
+      assert.match(editPreview?.notice ?? "", /outside the current workspace/);
+      assert.equal(writePreview?.previousContent, undefined);
+      assert.equal(writePreview?.nextContent, "replacement\n");
+      assert.match(writePreview?.notice ?? "", /outside the current workspace/);
+    } finally {
+      rmSync(outside, { recursive: true, force: true });
+    }
+  });
+});
+
+test("pending preview skips files over the read-size limit", () => {
+  withTempWorkspace("pi-tool-display-large-preview-", (workspace) => {
+    mkdirSync(join(workspace, "nested"));
+    const nestedFile = join(workspace, "nested", "large.txt");
+    writeFileSync(nestedFile, "x".repeat(1_000_001), "utf8");
+
+    const preview = buildPendingEditPreviewData(
+      { path: "nested/large.txt", oldText: "x", newText: "y" },
+      workspace,
+    );
+
+    assert.equal(preview?.previousContent, undefined);
+    assert.equal(preview?.nextContent, undefined);
+    assert.match(preview?.notice ?? "", /preview read limit/);
+  });
+});