gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0-dev.3cddbbba2

package/packages/pi-coding-agent/src/core/tools/ls.ts

@@ -3,6 +3,7 @@ import { type Static, Type } from "@sinclair/typebox";
 import { existsSync, readdirSync, statSync } from "fs";
 import nodePath from "path";
 import { resolveToCwd } from "./path-utils.js";
+import { createToolTarget, type ToolTargetMetadata } from "./tool-target.js";
 import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateHead } from "./truncate.js";
 
 const lsSchema = Type.Object({
@@ -15,6 +16,7 @@ export type LsToolInput = Static<typeof lsSchema>;
 const DEFAULT_LIMIT = 500;
 
 export interface LsToolDetails {
+	target?: ToolTargetMetadata;
 	truncation?: TruncationResult;
 	entryLimitReached?: number;
 }
@@ -68,6 +70,12 @@ export function createLsTool(cwd: string, options?: LsToolOptions): AgentTool<ty
 				(async () => {
 					try {
 						const dirPath = resolveToCwd(path || ".", cwd);
+						const target = createToolTarget({
+							kind: "directory",
+							action: "list",
+							inputPath: path || ".",
+							resolvedPath: dirPath,
+						});
 						const effectiveLimit = limit ?? DEFAULT_LIMIT;
 
 						// Check if path exists
@@ -124,7 +132,7 @@ export function createLsTool(cwd: string, options?: LsToolOptions): AgentTool<ty
 						signal?.removeEventListener("abort", onAbort);
 
 						if (results.length === 0) {
-							resolve({ content: [{ type: "text", text: "(empty directory)" }], details: undefined });
+							resolve({ content: [{ type: "text", text: "(empty directory)" }], details: { target } });
 							return;
 						}
 
@@ -133,7 +141,7 @@ export function createLsTool(cwd: string, options?: LsToolOptions): AgentTool<ty
 						const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
 
 						let output = truncation.content;
-						const details: LsToolDetails = {};
+						const details: LsToolDetails = { target };
 
 						// Build notices
 						const notices: string[] = [];
@@ -154,7 +162,7 @@ export function createLsTool(cwd: string, options?: LsToolOptions): AgentTool<ty
 
 						resolve({
 							content: [{ type: "text", text: output }],
-							details: Object.keys(details).length > 0 ? details : undefined,
+							details,
 						});
 					} catch (e: any) {
 						signal?.removeEventListener("abort", onAbort);

package/packages/pi-coding-agent/src/core/tools/read.ts

@@ -6,6 +6,7 @@ import { access as fsAccess, readFile as fsReadFile } from "fs/promises";
 import { formatDimensionNote, resizeImage } from "../../utils/image-resize.js";
 import { detectSupportedImageMimeTypeFromFile } from "../../utils/mime.js";
 import { resolveReadPath } from "./path-utils.js";
+import { createReadFileTarget, type ToolTargetMetadata } from "./tool-target.js";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationResult, truncateHead } from "./truncate.js";
 
 const readSchema = Type.Object({
@@ -17,6 +18,7 @@ const readSchema = Type.Object({
 export type ReadToolInput = Static<typeof readSchema>;
 
 export interface ReadToolDetails {
+	target?: ToolTargetMetadata;
 	truncation?: TruncationResult;
 }
 
@@ -61,6 +63,7 @@ export function createReadTool(cwd: string, options?: ReadToolOptions): AgentToo
 			signal?: AbortSignal,
 		) => {
 			const absolutePath = resolveReadPath(path, cwd);
+			const target = createReadFileTarget(path, absolutePath, offset, limit);
 
 			return new Promise<{ content: (TextContent | ImageContent)[]; details: ReadToolDetails | undefined }>(
 				(resolve, reject) => {
@@ -210,7 +213,7 @@ export function createReadTool(cwd: string, options?: ReadToolOptions): AgentToo
 								signal.removeEventListener("abort", onAbort);
 							}
 
-							resolve({ content, details });
+							resolve({ content, details: { ...details, target } });
 						} catch (error: any) {
 							// Clean up abort handler
 							if (signal) {

package/packages/pi-coding-agent/src/core/tools/spawn-shell-windows.test.ts

@@ -15,78 +15,17 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname, relative } from "node:path";
-import { fileURLToPath } from "node:url";
+import { execCommand } from "../exec.js";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const coreDir = join(__dirname, "..");
-
-/**
- * Files that call `spawn()` with a user-facing binary (not `node`, `sh`, `bash`,
- * or `cmd`) and therefore need the Windows shell guard.
- *
- * If a file spawns only hardcoded system binaries (like `node` in rpc-client.ts),
- * it does not need the guard and should NOT appear here.
- */
-const SPAWN_FILES_NEEDING_SHELL_GUARD = [
-	// Extension's GSD client — spawns the `gsd` binary which is a .cmd on Windows
-	join(coreDir, "..", "..", "..", "vscode-extension", "src", "gsd-client.ts"),
-	// exec.ts — used by extensions to run arbitrary commands
-	join(coreDir, "exec.ts"),
-	// LSP index — spawns project-type commands (tsc, cargo, etc.)
-	join(coreDir, "lsp", "index.ts"),
-	// LSP client — spawns LSP server binaries (npx, etc.)
-	join(coreDir, "lsp", "client.ts"),
-	// LSP mux — spawns lspmux binary
-	join(coreDir, "lsp", "lspmux.ts"),
-	// Package manager — spawns npm/yarn/pnpm
-	join(coreDir, "package-manager.ts"),
-];
-
-test("all spawn sites that invoke user-facing binaries include shell: process.platform === 'win32'", () => {
-	const failures: string[] = [];
-
-	for (const file of SPAWN_FILES_NEEDING_SHELL_GUARD) {
-		let content: string;
-		try {
-			content = readFileSync(file, "utf-8");
-		} catch {
-			// File may not exist in this checkout — skip
-			continue;
-		}
-
-		const lines = content.split("\n");
-
-		// Find all spawn(..., { ... }) call sites and check each one
-		// for the presence of `shell: process.platform === "win32"` within
-		// 5 lines after the spawn call.
-		for (let i = 0; i < lines.length; i++) {
-			const line = lines[i]!;
-			// Skip comments
-			if (line.trim().startsWith("//") || line.trim().startsWith("*")) continue;
-
-			// Detect a spawn() call
-			if (/\bspawn\(/.test(line)) {
-				// Look ahead up to 8 lines for the shell guard
-				const lookahead = lines.slice(i, i + 8).join("\n");
-				const hasShellGuard =
-					/shell:\s*process\.platform\s*===\s*["']win32["']/.test(lookahead);
-
-				if (!hasShellGuard) {
-					const relPath = relative(join(coreDir, "..", ".."), file);
-					failures.push(`${relPath}:${i + 1}`);
-				}
-			}
-		}
-	}
-
-	assert.deepEqual(
-		failures,
-		[],
-		`The following spawn sites are missing 'shell: process.platform === "win32"':\n` +
-		failures.map(f => `  - ${f}`).join("\n") +
-		`\nOn Windows, .cmd wrapper scripts (npm, npx, tsc, gsd) require shell ` +
-		`resolution. Without this guard, spawn fails with ENOENT or EINVAL.`,
+test("execCommand runs a user-facing binary and captures stdout", async () => {
+	const result = await execCommand(
+		process.execPath,
+		["-e", "process.stdout.write('ok')"],
+		process.cwd(),
 	);
+
+	assert.equal(result.stdout, "ok");
+	assert.equal(result.stderr, "");
+	assert.equal(result.code, 0);
+	assert.equal(result.killed, false);
 });

package/packages/pi-coding-agent/src/core/tools/tool-target-metadata.test.ts

@@ -0,0 +1,127 @@
+// GSD-2 - Behavior coverage for tool target metadata.
+
+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 { createEditTool } from "./edit.js";
+import { createFindTool } from "./find.js";
+import { createGrepTool } from "./grep.js";
+import { createLsTool } from "./ls.js";
+import { createReadTool } from "./read.js";
+import { createWriteTool } from "./write.js";
+
+test("read metadata records resolved path without changing output text", async () => {
+	const cwd = mkdtempSync(join(tmpdir(), "gsd-read-target-"));
+	try {
+		const filePath = join(cwd, "fixture.txt");
+		writeFileSync(filePath, "one\ntwo\nthree\n", "utf8");
+
+		const result = await createReadTool(cwd).execute("read-1", {
+			path: "fixture.txt",
+			offset: 2,
+			limit: 1,
+		});
+
+		assert.equal(result.details?.target?.resolvedPath, filePath);
+		assert.deepEqual(result.details?.target?.range, { start: 2, end: 2 });
+		assert.equal(result.content[0]?.type, "text");
+		assert.match(result.content[0]?.text ?? "", /^two/);
+		assert.equal((result.content[0]?.text ?? "").includes(filePath), false);
+
+		const zeroOffsetResult = await createReadTool(cwd).execute("read-zero-offset", {
+			path: "fixture.txt",
+			offset: 0,
+			limit: 1,
+		});
+
+		assert.deepEqual(zeroOffsetResult.details?.target?.range, { start: 1, end: 1 });
+	} finally {
+		rmSync(cwd, { recursive: true, force: true });
+	}
+});
+
+test("write metadata records resolved path without changing output text", async () => {
+	const cwd = mkdtempSync(join(tmpdir(), "gsd-write-target-"));
+	try {
+		const filePath = join(cwd, "out.txt");
+		const result = await createWriteTool(cwd).execute("write-1", {
+			path: "out.txt",
+			content: "hello",
+		});
+
+		assert.equal(result.details?.target?.resolvedPath, filePath);
+		assert.equal(result.content[0]?.type, "text");
+		assert.equal(result.content[0]?.text, "Successfully wrote 5 bytes to out.txt");
+	} finally {
+		rmSync(cwd, { recursive: true, force: true });
+	}
+});
+
+test("edit metadata records first changed line and resolved path", async () => {
+	const cwd = mkdtempSync(join(tmpdir(), "gsd-edit-target-"));
+	try {
+		const filePath = join(cwd, "edit.txt");
+		writeFileSync(filePath, "alpha\nbeta\ngamma\n", "utf8");
+
+		const result = await createEditTool(cwd).execute("edit-1", {
+			path: "edit.txt",
+			oldText: "beta",
+			newText: "delta",
+		});
+
+		assert.equal(result.details?.target?.resolvedPath, filePath);
+		assert.equal(result.details?.target?.line, 2);
+		assert.equal(result.details?.firstChangedLine, 2);
+	} finally {
+		rmSync(cwd, { recursive: true, force: true });
+	}
+});
+
+test("list and find metadata record resolved targets", async () => {
+	const cwd = mkdtempSync(join(tmpdir(), "gsd-search-target-"));
+	try {
+		const srcPath = join(cwd, "src");
+		const filePath = join(srcPath, "needle.txt");
+		mkdirSync(srcPath);
+		writeFileSync(filePath, "needle\n", "utf8");
+
+		const lsResult = await createLsTool(cwd).execute("ls-1", { path: "src" });
+		assert.equal(lsResult.details?.target?.resolvedPath, srcPath);
+
+		const findResult = await createFindTool(cwd, {
+			operations: {
+				exists: () => true,
+				glob: async () => [filePath],
+			},
+		}).execute("find-1", { path: "src", pattern: "needle" });
+		assert.equal(findResult.details?.target?.resolvedPath, srcPath);
+		assert.equal(findResult.details?.target?.pattern, "needle");
+	} finally {
+		rmSync(cwd, { recursive: true, force: true });
+	}
+});
+
+test("grep metadata records resolved search target", async () => {
+	const cwd = mkdtempSync(join(tmpdir(), "gsd-grep-target-"));
+	try {
+		const srcPath = join(cwd, "src");
+		mkdirSync(srcPath);
+		writeFileSync(join(srcPath, "needle.txt"), "needle\n", "utf8");
+
+		const result = await createGrepTool(cwd).execute("grep-1", {
+			path: "src",
+			pattern: "needle",
+			literal: true,
+		});
+
+		assert.equal(result.details?.target?.resolvedPath, srcPath);
+		assert.equal(result.details?.target?.pattern, "needle");
+		assert.equal(result.content[0]?.type, "text");
+		assert.match(result.content[0]?.text ?? "", /needle\.txt:1: needle/);
+	} finally {
+		rmSync(cwd, { recursive: true, force: true });
+	}
+});

package/packages/pi-coding-agent/src/core/tools/tool-target.ts

@@ -0,0 +1,48 @@
+// GSD-2 - Shared target metadata for tool output rendering.
+
+export type ToolTargetKind = "file" | "directory" | "search" | "command";
+
+export type ToolTargetAction = "read" | "write" | "edit" | "list" | "find" | "grep" | "bash";
+
+export interface ToolTargetRange {
+	start: number;
+	end?: number;
+}
+
+export interface ToolTargetMetadata {
+	kind: ToolTargetKind;
+	action: ToolTargetAction;
+	inputPath?: string;
+	resolvedPath?: string;
+	pattern?: string;
+	glob?: string;
+	line?: number;
+	range?: ToolTargetRange;
+}
+
+export function createToolTarget(target: ToolTargetMetadata): ToolTargetMetadata {
+	return target;
+}
+
+export function createReadFileTarget(
+	inputPath: string,
+	resolvedPath: string,
+	offset?: number,
+	limit?: number,
+): ToolTargetMetadata {
+	const effectiveOffset = Math.max(1, offset ?? 1);
+
+	return createToolTarget({
+		kind: "file",
+		action: "read",
+		inputPath,
+		resolvedPath,
+		range:
+			offset !== undefined || limit !== undefined
+				? {
+						start: effectiveOffset,
+						end: limit !== undefined ? effectiveOffset + Math.max(0, limit - 1) : undefined,
+					}
+				: undefined,
+	});
+}

package/packages/pi-coding-agent/src/core/tools/write.ts

@@ -4,6 +4,7 @@ import { mkdir as fsMkdir, writeFile as fsWriteFile } from "fs/promises";
 import { dirname } from "path";
 import { notifyFileChanged } from "../lsp/client.js";
 import { resolveToCwd } from "./path-utils.js";
+import { createToolTarget, type ToolTargetMetadata } from "./tool-target.js";
 
 const writeSchema = Type.Object({
 	path: Type.String({ description: "Path to the file to write (relative or absolute)" }),
@@ -12,6 +13,10 @@ const writeSchema = Type.Object({
 
 export type WriteToolInput = Static<typeof writeSchema>;
 
+export interface WriteToolDetails {
+	target?: ToolTargetMetadata;
+}
+
 /**
  * Pluggable operations for the write tool.
  * Override these to delegate file writing to remote systems (e.g., SSH).
@@ -50,7 +55,7 @@ export function createWriteTool(cwd: string, options?: WriteToolOptions): AgentT
 			const absolutePath = resolveToCwd(path, cwd);
 			const dir = dirname(absolutePath);
 
-			return new Promise<{ content: Array<{ type: "text"; text: string }>; details: undefined }>(
+			return new Promise<{ content: Array<{ type: "text"; text: string }>; details: WriteToolDetails | undefined }>(
 				(resolve, reject) => {
 					// Check if already aborted
 					if (signal?.aborted) {
@@ -98,7 +103,14 @@ export function createWriteTool(cwd: string, options?: WriteToolOptions): AgentT
 
 							resolve({
 								content: [{ type: "text", text: `Successfully wrote ${content.length} bytes to ${path}` }],
-								details: undefined,
+								details: {
+									target: createToolTarget({
+										kind: "file",
+										action: "write",
+										inputPath: path,
+										resolvedPath: absolutePath,
+									}),
+								},
 							});
 						} catch (error: any) {
 							// Clean up abort handler

package/packages/pi-coding-agent/src/modes/interactive/components/__tests__/assistant-message-design.test.ts

@@ -0,0 +1,56 @@
+// Project/App: GSD-2
+// File Purpose: Visual contract tests for the recommended indented assistant message rail design.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import stripAnsi from "strip-ansi";
+import type { AssistantMessage } from "@gsd/pi-ai";
+
+import { initTheme } from "../../theme/theme.js";
+import { AssistantMessageComponent } from "../assistant-message.js";
+import { formatTimestamp } from "../timestamp.js";
+
+initTheme("dark", false);
+
+describe("AssistantMessageComponent recommended rail design", () => {
+	test("renders assistant content with a lightly indented left rail", () => {
+		const message = {
+			id: "m1",
+			role: "assistant",
+			provider: "test",
+			model: "gpt-test",
+			timestamp: 1,
+			content: [{ type: "text", text: "I will update the renderer and run verification." }],
+		} as unknown as AssistantMessage;
+
+		const component = new AssistantMessageComponent(message, true);
+		const raw = component.render(80);
+		const plain = raw.map((line) => stripAnsi(line));
+		const joined = plain.join("\n");
+
+		assert.ok(plain.some((line) => line.startsWith("  ┃ ")), `expected indented rail-prefixed lines:\n${joined}`);
+		assert.ok(raw.some((line) => line.includes("\x1b[48;")), `expected faint assistant block background:\n${raw.join("\n")}`);
+		assert.match(joined, /^\s*┃\s*$/m, "assistant block should include vertical padding rows");
+		assert.match(joined, /GSD/);
+		assert.match(joined, /gpt-test/);
+		assert.match(joined, /update the renderer/);
+		assert.doesNotMatch(joined, /^┃/m, "assistant rail should be slightly indented from the left edge");
+		assert.doesNotMatch(joined, /^╭/m, "assistant messages should not use rounded card borders");
+	});
+
+	test("renders metadata for a zero timestamp", () => {
+		const message = {
+			id: "m1",
+			role: "assistant",
+			provider: "test",
+			model: "gpt-test",
+			timestamp: 0,
+			content: [{ type: "text", text: "Finished." }],
+		} as unknown as AssistantMessage;
+
+		const component = new AssistantMessageComponent(message, true);
+		const joined = component.render(80).map((line) => stripAnsi(line)).join("\n");
+
+		assert.match(joined, new RegExp(formatTimestamp(0)));
+	});
+});