gsd-pi 2.8.3 → 2.10.0

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

@@ -1,10 +1,8 @@
 import type { AgentTool } from "@gsd/pi-agent-core";
+import { glob as nativeGlob } from "@gsd/native/glob";
 import { type Static, Type } from "@sinclair/typebox";
-import { spawnSync } from "child_process";
 import { existsSync } from "fs";
-import { globSync } from "glob";
 import path from "path";
-import { ensureTool } from "../../utils/tools-manager.js";
 import { resolveToCwd } from "./path-utils.js";
 import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateHead } from "./truncate.js";
 
@@ -39,13 +37,13 @@ export interface FindOperations {
 const defaultFindOperations: FindOperations = {
 	exists: existsSync,
 	glob: (_pattern, _searchCwd, _options) => {
-		// This is a placeholder - actual fd execution happens in execute
+		// Placeholder — actual native glob execution happens in execute
 		return [];
 	},
 };
 
 export interface FindToolOptions {
-	/** Custom operations for find. Default: local filesystem + fd */
+	/** Custom operations for find. Default: local filesystem + native glob */
 	operations?: FindOperations;
 }
 
@@ -136,72 +134,18 @@ export function createFindTool(cwd: string, options?: FindToolOptions): AgentToo
 							return;
 						}
 
-						// Default: use fd
-						const fdPath = await ensureTool("fd", true);
-						if (!fdPath) {
-							reject(new Error("fd is not available and could not be downloaded"));
-							return;
-						}
-
-						// Build fd arguments
-						const args: string[] = [
-							"--glob",
-							"--color=never",
-							"--hidden",
-							"--max-results",
-							String(effectiveLimit),
-						];
-
-						// Include .gitignore files
-						const gitignoreFiles = new Set<string>();
-						const rootGitignore = path.join(searchPath, ".gitignore");
-						if (existsSync(rootGitignore)) {
-							gitignoreFiles.add(rootGitignore);
-						}
-
-						try {
-							const nestedGitignores = globSync("**/.gitignore", {
-								cwd: searchPath,
-								dot: true,
-								absolute: true,
-								ignore: ["**/node_modules/**", "**/.git/**"],
-							});
-							for (const file of nestedGitignores) {
-								gitignoreFiles.add(file);
-							}
-						} catch {
-							// Ignore glob errors
-						}
-
-						for (const gitignorePath of gitignoreFiles) {
-							args.push("--ignore-file", gitignorePath);
-						}
-
-						args.push(pattern, searchPath);
-
-						const result = spawnSync(fdPath, args, {
-							encoding: "utf-8",
-							maxBuffer: 10 * 1024 * 1024,
+						// Default: use native Rust glob
+						const globResult = await nativeGlob({
+							pattern,
+							path: searchPath,
+							hidden: true,
+							gitignore: true,
+							maxResults: effectiveLimit,
 						});
 
 						signal?.removeEventListener("abort", onAbort);
 
-						if (result.error) {
-							reject(new Error(`Failed to run fd: ${result.error.message}`));
-							return;
-						}
-
-						const output = result.stdout?.trim() || "";
-
-						if (result.status !== 0) {
-							const errorMsg = result.stderr?.trim() || `fd exited with code ${result.status}`;
-							if (!output) {
-								reject(new Error(errorMsg));
-								return;
-							}
-						}
-
-						if (!output) {
+						if (globResult.matches.length === 0) {
 							resolve({
 								content: [{ type: "text", text: "No files found matching pattern" }],
 								details: undefined,
@@ -209,27 +153,8 @@ export function createFindTool(cwd: string, options?: FindToolOptions): AgentToo
 							return;
 						}
 
-						const lines = output.split("\n");
-						const relativized: string[] = [];
-
-						for (const rawLine of lines) {
-							const line = rawLine.replace(/\r$/, "").trim();
-							if (!line) continue;
-
-							const hadTrailingSlash = line.endsWith("/") || line.endsWith("\\");
-							let relativePath = line;
-							if (line.startsWith(searchPath)) {
-								relativePath = line.slice(searchPath.length + 1);
-							} else {
-								relativePath = path.relative(searchPath, line);
-							}
-
-							if (hadTrailingSlash && !relativePath.endsWith("/")) {
-								relativePath += "/";
-							}
-
-							relativized.push(relativePath);
-						}
+						// Native glob returns paths relative to the search root
+						const relativized = globResult.matches.map((m: { path: string }) => m.path);
 
 						const resultLimitReached = relativized.length >= effectiveLimit;
 						const rawOutput = relativized.join("\n");

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

@@ -0,0 +1,318 @@
+/**
+ * Hashline edit tool — applies file edits using line-hash anchors.
+ *
+ * The model references lines by `LINE#ID` tags from read output.
+ * Each tag uniquely identifies a line, so edits remain stable even when lines shift.
+ */
+import type { AgentTool } from "@gsd/pi-agent-core";
+import { type Static, Type } from "@sinclair/typebox";
+import { constants } from "fs";
+import { access as fsAccess, readFile as fsReadFile, unlink as fsUnlink, writeFile as fsWriteFile } from "fs/promises";
+import {
+	detectLineEnding,
+	generateDiffString,
+	normalizeToLF,
+	restoreLineEndings,
+	stripBom,
+} from "./edit-diff.js";
+import {
+	type Anchor,
+	applyHashlineEdits,
+	computeLineHash,
+	type HashlineEdit,
+	hashlineParseText,
+	parseTag,
+} from "./hashline.js";
+import { resolveToCwd } from "./path-utils.js";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Schema
+// ═══════════════════════════════════════════════════════════════════════════
+
+const hashlineEditItemSchema = Type.Object(
+	{
+		op: Type.Union([Type.Literal("replace"), Type.Literal("append"), Type.Literal("prepend")]),
+		pos: Type.Optional(Type.String({ description: "Anchor tag (e.g. \"5#QQ\")" })),
+		end: Type.Optional(Type.String({ description: "End anchor for range replace" })),
+		lines: Type.Union([
+			Type.Array(Type.String(), { description: "Replacement content lines" }),
+			Type.String(),
+			Type.Null(),
+		]),
+	},
+	{ additionalProperties: false },
+);
+
+const hashlineEditSchema = Type.Object(
+	{
+		path: Type.String({ description: "Path to the file to edit" }),
+		edits: Type.Array(hashlineEditItemSchema, { description: "Edits to apply (referenced by LINE#ID tags from read output)" }),
+		delete: Type.Optional(Type.Boolean({ description: "If true, delete the file" })),
+		move: Type.Optional(Type.String({ description: "If set, move/rename the file to this path" })),
+	},
+	{ additionalProperties: false },
+);
+
+export type HashlineEditInput = Static<typeof hashlineEditSchema>;
+export type HashlineEditItem = Static<typeof hashlineEditItemSchema>;
+
+export interface HashlineEditToolDetails {
+	/** Unified diff of the changes made */
+	diff: string;
+	/** Line number of the first change in the new file */
+	firstChangedLine?: number;
+}
+
+/**
+ * Pluggable operations for the hashline edit tool.
+ */
+export interface HashlineEditOperations {
+	readFile: (absolutePath: string) => Promise<Buffer>;
+	writeFile: (absolutePath: string, content: string) => Promise<void>;
+	access: (absolutePath: string) => Promise<void>;
+	unlink: (absolutePath: string) => Promise<void>;
+}
+
+const defaultHashlineEditOperations: HashlineEditOperations = {
+	readFile: (path) => fsReadFile(path),
+	writeFile: (path, content) => fsWriteFile(path, content, "utf-8"),
+	access: (path) => fsAccess(path, constants.R_OK | constants.W_OK),
+	unlink: (path) => fsUnlink(path),
+};
+
+export interface HashlineEditToolOptions {
+	operations?: HashlineEditOperations;
+}
+
+/** Parse a tag, returning undefined instead of throwing on garbage. */
+function tryParseTag(raw: string): Anchor | undefined {
+	try {
+		return parseTag(raw);
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * Map flat tool-schema edits into typed HashlineEdit objects.
+ */
+function resolveEditAnchors(edits: HashlineEditItem[]): HashlineEdit[] {
+	const result: HashlineEdit[] = [];
+	for (const edit of edits) {
+		const lines = hashlineParseText(edit.lines);
+		const tag = edit.pos ? tryParseTag(edit.pos) : undefined;
+		const end = edit.end ? tryParseTag(edit.end) : undefined;
+
+		const op = edit.op === "append" || edit.op === "prepend" ? edit.op : "replace";
+		switch (op) {
+			case "replace": {
+				if (tag && end) {
+					result.push({ op: "replace", pos: tag, end, lines });
+				} else if (tag || end) {
+					result.push({ op: "replace", pos: tag || end!, lines });
+				} else {
+					throw new Error("Replace requires at least one anchor (pos or end).");
+				}
+				break;
+			}
+			case "append": {
+				result.push({ op: "append", pos: tag ?? end, lines });
+				break;
+			}
+			case "prepend": {
+				result.push({ op: "prepend", pos: end ?? tag, lines });
+				break;
+			}
+		}
+	}
+	return result;
+}
+
+const HASHLINE_EDIT_DESCRIPTION = `Edit a file by referencing LINE#ID tags from read output. Each tag uniquely identifies a line via content hash, so edits remain stable even when lines shift.
+
+Read the file first to get fresh tags. Submit one edit call per file with all operations batched.
+
+Operations:
+- replace: Replace line(s) at pos (and optionally through end) with lines content
+- append: Insert lines after pos (omit pos for end of file)
+- prepend: Insert lines before pos (omit pos for beginning of file)
+
+Set lines to null or [] to delete lines. Set delete:true to delete the file.`;
+
+export function createHashlineEditTool(cwd: string, options?: HashlineEditToolOptions): AgentTool<typeof hashlineEditSchema> {
+	const ops = options?.operations ?? defaultHashlineEditOperations;
+
+	return {
+		name: "hashline_edit",
+		label: "hashline_edit",
+		description: HASHLINE_EDIT_DESCRIPTION,
+		parameters: hashlineEditSchema,
+		execute: async (
+			_toolCallId: string,
+			params: HashlineEditInput,
+			signal?: AbortSignal,
+		) => {
+			const { path, edits, delete: deleteFile, move } = params;
+			const absolutePath = resolveToCwd(path, cwd);
+
+			return new Promise<{
+				content: Array<{ type: "text"; text: string }>;
+				details: HashlineEditToolDetails | undefined;
+			}>((resolve, reject) => {
+				if (signal?.aborted) {
+					reject(new Error("Operation aborted"));
+					return;
+				}
+
+				let aborted = false;
+				const onAbort = () => {
+					aborted = true;
+					reject(new Error("Operation aborted"));
+				};
+				if (signal) {
+					signal.addEventListener("abort", onAbort, { once: true });
+				}
+
+				(async () => {
+					try {
+						// Handle delete
+						if (deleteFile) {
+							let fileExists = true;
+							try {
+								await ops.access(absolutePath);
+							} catch {
+								fileExists = false;
+							}
+							if (fileExists) {
+								await ops.unlink(absolutePath);
+							}
+							if (signal) signal.removeEventListener("abort", onAbort);
+							resolve({
+								content: [{ type: "text", text: fileExists ? `Deleted ${path}` : `File not found, nothing to delete: ${path}` }],
+								details: { diff: "" },
+							});
+							return;
+						}
+
+						// Handle file creation (no existing file, anchorless appends/prepends)
+						let fileExists = true;
+						try {
+							await ops.access(absolutePath);
+						} catch {
+							fileExists = false;
+						}
+
+						if (!fileExists) {
+							const lines: string[] = [];
+							for (const edit of edits) {
+								if ((edit.op === "append" || edit.op === "prepend") && !edit.pos && !edit.end) {
+									if (edit.op === "prepend") {
+										lines.unshift(...hashlineParseText(edit.lines));
+									} else {
+										lines.push(...hashlineParseText(edit.lines));
+									}
+								} else {
+									throw new Error(`File not found: ${path}`);
+								}
+							}
+							await ops.writeFile(absolutePath, lines.join("\n"));
+							if (signal) signal.removeEventListener("abort", onAbort);
+							resolve({
+								content: [{ type: "text", text: `Created ${path}` }],
+								details: { diff: "" },
+							});
+							return;
+						}
+
+						if (aborted) return;
+
+						// Read file
+						const rawContent = (await ops.readFile(absolutePath)).toString("utf-8");
+						const { bom, text } = stripBom(rawContent);
+						const originalEnding = detectLineEnding(text);
+						const originalNormalized = normalizeToLF(text);
+
+						if (aborted) return;
+
+						// Resolve and apply edits
+						const anchorEdits = resolveEditAnchors(edits);
+						const result = applyHashlineEdits(originalNormalized, anchorEdits);
+
+						if (originalNormalized === result.lines && !move) {
+							let diagnostic = `No changes made to ${path}. The edits produced identical content.`;
+							if (result.noopEdits && result.noopEdits.length > 0) {
+								const details = result.noopEdits
+									.map(
+										e =>
+											`Edit ${e.editIndex}: replacement for ${e.loc} is identical to current content:\n  ${e.loc}| ${e.current}`,
+									)
+									.join("\n");
+								diagnostic += `\n${details}`;
+								diagnostic +=
+									"\nYour content must differ from what the file already contains. Re-read the file to see the current state.";
+							}
+							throw new Error(diagnostic);
+						}
+
+						if (aborted) return;
+
+						// Write result
+						const finalContent = bom + restoreLineEndings(result.lines, originalEnding);
+						const writePath = move ? resolveToCwd(move, cwd) : absolutePath;
+
+						// Prevent silent overwrite when moving to an existing file
+						if (move && writePath !== absolutePath) {
+							try {
+								await ops.access(writePath);
+								// If access succeeds, the file exists — refuse the move
+								throw new Error(`Destination file already exists: ${writePath}. Use a different path or delete the existing file first.`);
+							} catch (err: any) {
+								// Re-throw our own error; swallow only "file not found"
+								if (err.message?.startsWith("Destination file already exists:")) throw err;
+								// File doesn't exist — safe to proceed
+							}
+						}
+
+						await ops.writeFile(writePath, finalContent);
+
+						// If moved, delete original
+						if (move && writePath !== absolutePath) {
+							await ops.unlink(absolutePath);
+						}
+
+						if (aborted) return;
+
+						if (signal) signal.removeEventListener("abort", onAbort);
+
+						const diffResult = generateDiffString(originalNormalized, result.lines);
+						const resultText = move ? `Moved ${path} to ${move}` : `Updated ${path}`;
+						const warningsBlock = result.warnings?.length
+							? `\nWarnings:\n${result.warnings.join("\n")}`
+							: "";
+
+						resolve({
+							content: [
+								{
+									type: "text",
+									text: `${resultText}${warningsBlock}`,
+								},
+							],
+							details: {
+								diff: diffResult.diff,
+								firstChangedLine: result.firstChangedLine ?? diffResult.firstChangedLine,
+							},
+						});
+					} catch (error: any) {
+						if (signal) signal.removeEventListener("abort", onAbort);
+						if (!aborted) {
+							reject(error);
+						}
+					}
+				})();
+			});
+		},
+	};
+}
+
+/** Default hashline edit tool using process.cwd() */
+export const hashlineEditTool = createHashlineEditTool(process.cwd());

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

@@ -0,0 +1,196 @@
+/**
+ * Hashline read tool — reads files with LINE#ID prefix on each line.
+ *
+ * Produces output like:
+ *   1#QQ:function hello() {
+ *   2#KX:  return 42;
+ *   3#NW:}
+ *
+ * These tags are used by the hashline_edit tool to address lines precisely.
+ */
+import type { AgentTool } from "@gsd/pi-agent-core";
+import type { ImageContent, TextContent } from "@gsd/pi-ai";
+import { type Static, Type } from "@sinclair/typebox";
+import { constants } from "fs";
+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 { formatHashLines } from "./hashline.js";
+import { resolveReadPath } from "./path-utils.js";
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationResult, truncateHead } from "./truncate.js";
+
+const readSchema = Type.Object({
+	path: Type.String({ description: "Path to the file to read (relative or absolute)" }),
+	offset: Type.Optional(Type.Number({ description: "Line number to start reading from (1-indexed)" })),
+	limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read" })),
+});
+
+export type HashlineReadToolInput = Static<typeof readSchema>;
+
+export interface HashlineReadToolDetails {
+	truncation?: TruncationResult;
+}
+
+/**
+ * Pluggable operations for the hashline read tool.
+ */
+export interface HashlineReadOperations {
+	readFile: (absolutePath: string) => Promise<Buffer>;
+	access: (absolutePath: string) => Promise<void>;
+	detectImageMimeType?: (absolutePath: string) => Promise<string | null | undefined>;
+}
+
+const defaultReadOperations: HashlineReadOperations = {
+	readFile: (path) => fsReadFile(path),
+	access: (path) => fsAccess(path, constants.R_OK),
+	detectImageMimeType: detectSupportedImageMimeTypeFromFile,
+};
+
+export interface HashlineReadToolOptions {
+	autoResizeImages?: boolean;
+	operations?: HashlineReadOperations;
+}
+
+export function createHashlineReadTool(cwd: string, options?: HashlineReadToolOptions): AgentTool<typeof readSchema> {
+	const autoResizeImages = options?.autoResizeImages ?? true;
+	const ops = options?.operations ?? defaultReadOperations;
+
+	return {
+		name: "read",
+		label: "read",
+		description: `Read a file with LINE#ID hash anchors on each line. These anchors are used by hashline_edit for precise edits. Output format: LINENUM#HASH:CONTENT. Supports text files and images. For text files, output is truncated to ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB. Use offset/limit for large files.`,
+		parameters: readSchema,
+		execute: async (
+			_toolCallId: string,
+			{ path, offset, limit }: { path: string; offset?: number; limit?: number },
+			signal?: AbortSignal,
+		) => {
+			const absolutePath = resolveReadPath(path, cwd);
+
+			return new Promise<{ content: (TextContent | ImageContent)[]; details: HashlineReadToolDetails | undefined }>(
+				(resolve, reject) => {
+					if (signal?.aborted) {
+						reject(new Error("Operation aborted"));
+						return;
+					}
+
+					let aborted = false;
+					const onAbort = () => {
+						aborted = true;
+						reject(new Error("Operation aborted"));
+					};
+					if (signal) {
+						signal.addEventListener("abort", onAbort, { once: true });
+					}
+
+					(async () => {
+						try {
+							await ops.access(absolutePath);
+
+							if (aborted) return;
+
+							const mimeType = ops.detectImageMimeType ? await ops.detectImageMimeType(absolutePath) : undefined;
+
+							let content: (TextContent | ImageContent)[];
+							let details: HashlineReadToolDetails | undefined;
+
+							if (mimeType) {
+								// Image handling (identical to standard read tool)
+								const buffer = await ops.readFile(absolutePath);
+								const base64 = buffer.toString("base64");
+
+								if (autoResizeImages) {
+									const resized = await resizeImage({ type: "image", data: base64, mimeType });
+									const dimensionNote = formatDimensionNote(resized);
+									let textNote = `Read image file [${resized.mimeType}]`;
+									if (dimensionNote) {
+										textNote += `\n${dimensionNote}`;
+									}
+									content = [
+										{ type: "text", text: textNote },
+										{ type: "image", data: resized.data, mimeType: resized.mimeType },
+									];
+								} else {
+									content = [
+										{ type: "text", text: `Read image file [${mimeType}]` },
+										{ type: "image", data: base64, mimeType },
+									];
+								}
+							} else {
+								// Text file — format with hashline prefixes
+								const buffer = await ops.readFile(absolutePath);
+								const textContent = buffer.toString("utf-8");
+								const allLines = textContent.split("\n");
+								const totalFileLines = allLines.length;
+
+								const startLine = offset ? Math.max(0, offset - 1) : 0;
+								const startLineDisplay = startLine + 1;
+
+								if (startLine >= allLines.length) {
+									throw new Error(`Offset ${offset} is beyond end of file (${allLines.length} lines total)`);
+								}
+
+								let selectedContent: string;
+								let userLimitedLines: number | undefined;
+								if (limit !== undefined) {
+									const endLine = Math.min(startLine + limit, allLines.length);
+									selectedContent = allLines.slice(startLine, endLine).join("\n");
+									userLimitedLines = endLine - startLine;
+								} else {
+									selectedContent = allLines.slice(startLine).join("\n");
+								}
+
+								// Apply truncation
+								const truncation = truncateHead(selectedContent);
+
+								let outputText: string;
+
+								if (truncation.firstLineExceedsLimit) {
+									const firstLineSize = formatSize(Buffer.byteLength(allLines[startLine], "utf-8"));
+									outputText = `[Line ${startLineDisplay} is ${firstLineSize}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit. Use bash: sed -n '${startLineDisplay}p' ${path} | head -c ${DEFAULT_MAX_BYTES}]`;
+									details = { truncation };
+								} else if (truncation.truncated) {
+									const endLineDisplay = startLineDisplay + truncation.outputLines - 1;
+									const nextOffset = endLineDisplay + 1;
+
+									// Format with hashline prefixes
+									outputText = formatHashLines(truncation.content, startLineDisplay);
+
+									if (truncation.truncatedBy === "lines") {
+										outputText += `\n\n[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use offset=${nextOffset} to continue.]`;
+									} else {
+										outputText += `\n\n[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Use offset=${nextOffset} to continue.]`;
+									}
+									details = { truncation };
+								} else if (userLimitedLines !== undefined && startLine + userLimitedLines < allLines.length) {
+									const remaining = allLines.length - (startLine + userLimitedLines);
+									const nextOffset = startLine + userLimitedLines + 1;
+
+									outputText = formatHashLines(truncation.content, startLineDisplay);
+									outputText += `\n\n[${remaining} more lines in file. Use offset=${nextOffset} to continue.]`;
+								} else {
+									outputText = formatHashLines(truncation.content, startLineDisplay);
+								}
+
+								content = [{ type: "text", text: outputText }];
+							}
+
+							if (aborted) return;
+
+							if (signal) signal.removeEventListener("abort", onAbort);
+							resolve({ content, details });
+						} catch (error: any) {
+							if (signal) signal.removeEventListener("abort", onAbort);
+							if (!aborted) {
+								reject(error);
+							}
+						}
+					})();
+				},
+			);
+		},
+	};
+}
+
+/** Default hashline read tool using process.cwd() */
+export const hashlineReadTool = createHashlineReadTool(process.cwd());