@oh-my-pi/pi-coding-agent 14.7.7 → 14.8.0

package/src/tools/read.ts

@@ -8,6 +8,7 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { getRemoteDir, prompt, readImageMetadata, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
+import { getFileReadCache } from "../edit/file-read-cache";
 import { formatHashLine, formatHashLines, formatLineHash, HL_BODY_SEP } from "../edit/line-hash";
 import { isNotebookPath, readEditableNotebookText } from "../edit/notebook";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
@@ -163,6 +164,33 @@ function countTextLines(text: string): number {
 }
 const READ_CHUNK_SIZE = 8 * 1024;
 
+/**
+ * Number of unanchored context lines to include before/after a user-requested
+ * range. Anchor-stale failures are heavily concentrated on edits whose anchors
+ * land just outside the most recent read window — a few lines of pre-anchored
+ * context covers off-by-one anchor selection without much cost.
+ */
+const RANGE_CONTEXT_LINES = 3;
+
+/**
+ * Expand a [start, end) range with ±RANGE_CONTEXT_LINES context lines on the
+ * sides where the user actually constrained the range. A start of 0 (no
+ * explicit offset) does not get leading context — that's already an open-ended
+ * read from the top.
+ */
+function expandRangeWithContext(
+	requestedStart: number,
+	requestedEnd: number,
+	totalLines: number,
+	expandStart: boolean,
+	expandEnd: boolean,
+): { startLine: number; endLine: number } {
+	return {
+		startLine: expandStart ? Math.max(0, requestedStart - RANGE_CONTEXT_LINES) : requestedStart,
+		endLine: expandEnd ? Math.min(totalLines, requestedEnd + RANGE_CONTEXT_LINES) : requestedEnd,
+	};
+}
+
 async function streamLinesFromFile(
 	filePath: string,
 	startLine: number,
@@ -645,9 +673,26 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		const details = options.details ?? {};
 		const allLines = text.split("\n");
 		const totalLines = allLines.length;
-		const startLine = offset ? Math.max(0, offset - 1) : 0;
-		const startLineDisplay = startLine + 1;
+		// User-requested 0-indexed range start. Lines BEFORE this are leading
+		// context (added below if offset is explicit).
+		const requestedStart = offset ? Math.max(0, offset - 1) : 0;
 		const ignoreResultLimits = options.ignoreResultLimits ?? false;
+		const requestedEnd =
+			limit !== undefined && !ignoreResultLimits
+				? Math.min(requestedStart + limit, allLines.length)
+				: allLines.length;
+		// Expand only on sides the user actually constrained: leading context
+		// when offset>1, trailing context when a finite limit was set.
+		const expanded = expandRangeWithContext(
+			requestedStart,
+			requestedEnd,
+			allLines.length,
+			offset !== undefined && offset > 1,
+			limit !== undefined && !ignoreResultLimits,
+		);
+		const startLine = expanded.startLine;
+		const endLineExpanded = expanded.endLine;
+		const startLineDisplay = startLine + 1;
 
 		const resultBuilder = toolResult(details);
 		if (options.sourcePath) {
@@ -660,20 +705,19 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			resultBuilder.sourceInternal(options.sourceInternal);
 		}
 
-		if (startLine >= allLines.length) {
+		if (requestedStart >= allLines.length) {
 			const suggestion =
 				allLines.length === 0
 					? `The ${options.entityLabel} is empty.`
 					: `Use :1 to read from the start, or :${allLines.length} to read the last line.`;
 			return resultBuilder
 				.text(
-					`Line ${startLineDisplay} is beyond end of ${options.entityLabel} (${allLines.length} lines total). ${suggestion}`,
+					`Line ${requestedStart + 1} is beyond end of ${options.entityLabel} (${allLines.length} lines total). ${suggestion}`,
 				)
 				.done();
 		}
 
-		const endLine =
-			limit !== undefined && !ignoreResultLimits ? Math.min(startLine + limit, allLines.length) : allLines.length;
+		const endLine = endLineExpanded;
 		const selectedContent = allLines.slice(startLine, endLine).join("\n");
 		const userLimitedLines = limit !== undefined && !ignoreResultLimits ? endLine - startLine : undefined;
 		const truncation = ignoreResultLimits ? noTruncResult(selectedContent) : truncateHead(selectedContent);
@@ -1318,13 +1362,20 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			if (!content) {
 				// Raw text or line-range mode
 				const { offset, limit } = selToOffsetLimit(parsed);
-				const startLine = offset ? Math.max(0, offset - 1) : 0;
+				// User-requested 0-indexed range start. Lines BEFORE this become
+				// leading context (added below if offset is explicit).
+				const requestedStart = offset ? Math.max(0, offset - 1) : 0;
+				const expandStart = offset !== undefined && offset > 1;
+				const expandEnd = limit !== undefined;
+				const leadingContext = expandStart ? Math.min(requestedStart, RANGE_CONTEXT_LINES) : 0;
+				const trailingContext = expandEnd ? RANGE_CONTEXT_LINES : 0;
+				const startLine = requestedStart - leadingContext;
 				const startLineDisplay = startLine + 1;
 
 				const DEFAULT_LIMIT = this.#defaultLimit;
 				const effectiveLimit = limit ?? DEFAULT_LIMIT;
-				const maxLinesToCollect = Math.min(effectiveLimit, DEFAULT_MAX_LINES);
-				const selectedLineLimit = effectiveLimit;
+				const maxLinesToCollect = Math.min(effectiveLimit + leadingContext + trailingContext, DEFAULT_MAX_LINES);
+				const selectedLineLimit = effectiveLimit + leadingContext + trailingContext;
 				// Scale byte budget with line limit so the configured line count actually fits.
 				// Assume ~512 bytes/line average; never go below the shared default.
 				const maxBytesForRead = Math.max(DEFAULT_MAX_BYTES, maxLinesToCollect * 512);
@@ -1348,13 +1399,15 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				} = streamResult;
 
 				// Check if offset is out of bounds - return graceful message instead of throwing
-				if (startLine >= totalFileLines) {
+				if (requestedStart >= totalFileLines) {
 					const suggestion =
 						totalFileLines === 0
 							? "The file is empty."
 							: `Use :1 to read from the start, or :${totalFileLines} to read the last line.`;
 					return toolResult<ReadToolDetails>({ resolvedPath: absolutePath, suffixResolution })
-						.text(`Line ${startLineDisplay} is beyond end of file (${totalFileLines} lines total). ${suggestion}`)
+						.text(
+							`Line ${requestedStart + 1} is beyond end of file (${totalFileLines} lines total). ${suggestion}`,
+						)
 						.done();
 				}
 
@@ -1378,6 +1431,10 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					firstLineExceedsLimit,
 				};
 
+				if (collectedLines.length > 0 && !firstLineExceedsLimit) {
+					getFileReadCache(this.session).recordContiguous(absolutePath, startLineDisplay, collectedLines);
+				}
+
 				const isRawMode = parsed.kind === "raw";
 				const shouldAddHashLines = !isRawMode && displayMode.hashLines;
 				const shouldAddLineNumbers = isRawMode ? false : shouldAddHashLines ? false : displayMode.lineNumbers;

package/src/tools/search.ts

@@ -6,6 +6,7 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
+import { getFileReadCache } from "../edit/file-read-cache";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import searchDescription from "../prompts/tools/search.md" with { type: "text" };
@@ -345,27 +346,32 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 					}
 					return nextWidth;
 				}, 0);
+				const cacheEntries: Array<readonly [number, string]> = [];
 				for (const match of fileMatches) {
-					const pushLine = (lineNumber: number, line: string, isMatch: boolean) => {
+					const pushLine = (lineNumber: number, line: string, isMatch: boolean, recordable: boolean) => {
 						modelOut.push(formatMatchLine(lineNumber, line, isMatch, { useHashLines }));
 						displayOut.push(formatCodeFrameLine(isMatch ? "*" : " ", lineNumber, line, lineNumberWidth));
+						if (recordable) cacheEntries.push([lineNumber, line] as const);
 					};
 					if (match.contextBefore) {
 						for (const ctx of match.contextBefore) {
-							pushLine(ctx.lineNumber, ctx.line, false);
+							pushLine(ctx.lineNumber, ctx.line, false, true);
 						}
 					}
-					pushLine(match.lineNumber, match.line, true);
+					pushLine(match.lineNumber, match.line, true, !match.truncated);
 					if (match.truncated) {
 						linesTruncated = true;
 					}
 					if (match.contextAfter) {
 						for (const ctx of match.contextAfter) {
-							pushLine(ctx.lineNumber, ctx.line, false);
+							pushLine(ctx.lineNumber, ctx.line, false, true);
 						}
 					}
 					fileMatchCounts.set(relativePath, (fileMatchCounts.get(relativePath) ?? 0) + 1);
 				}
+				if (cacheEntries.length > 0) {
+					getFileReadCache(this.session).recordSparse(path.resolve(searchPath, relativePath), cacheEntries);
+				}
 				return { model: modelOut, display: displayOut };
 			};
 			if (isDirectory) {

package/src/utils/git.ts

@@ -40,6 +40,12 @@ export type HunkSelection = {
 	hunks: { type: "all" } | { type: "indices"; indices: number[] } | { type: "lines"; start: number; end: number };
 };
 
+export interface StageHunksOptions {
+	readonly diffCached?: boolean;
+	readonly rawDiff?: string;
+	readonly signal?: AbortSignal;
+}
+
 export interface DiffOptions {
 	readonly allowFailure?: boolean;
 	readonly base?: string;
@@ -803,10 +809,10 @@ export const stage = {
 		await runEffect(cwd, args, { signal });
 	},
 
-	/** Selectively stage hunks from the working tree diff. */
-	async hunks(cwd: string, selections: HunkSelection[], signal?: AbortSignal): Promise<void> {
+	/** Selectively stage hunks from the provided diff or the current working tree diff. */
+	async hunks(cwd: string, selections: HunkSelection[], options: StageHunksOptions = {}): Promise<void> {
 		if (selections.length === 0) return;
-		const rawDiff = await diff(cwd, { cached: false, signal });
+		const rawDiff = options.rawDiff ?? (await diff(cwd, { cached: options.diffCached, signal: options.signal }));
 		const fileDiffs = parseFileDiffs(rawDiff);
 		const fileDiffMap = new Map(fileDiffs.map(entry => [entry.filename, entry]));
 		const patchParts: string[] = [];
@@ -833,7 +839,7 @@ export const stage = {
 
 		const patchText = patch.join(patchParts);
 		if (!patchText.trim()) return;
-		await patch.applyText(cwd, patchText, { cached: true, signal });
+		await patch.applyText(cwd, patchText, { cached: true, signal: options.signal });
 	},
 
 	/** Unstage files. Empty array unstages all (`git reset`). */

package/src/workspace-tree.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { glob } from "@oh-my-pi/pi-natives";
-import { formatAge, formatBytes } from "@oh-my-pi/pi-utils";
+import { $which, formatAge, formatBytes, logger } from "@oh-my-pi/pi-utils";
 
 export interface DirectoryTree {
 	rootPath: string;
@@ -35,6 +35,13 @@ export interface DirectoryTreeOptions {
 	cache?: boolean;
 	/** Rendered label for the root line. */
 	rootLabel?: string;
+	/**
+	 * Pre-built map of `parentRelativePath` → child name set used in place of
+	 * native directory listing. When provided, the tree builder consults this
+	 * map for child enumeration instead of `glob` / `readdir`. Stat calls per
+	 * displayed node are still performed for mtime/size/dir-ness.
+	 */
+	childIndex?: ReadonlyMap<string, ReadonlySet<string>>;
 }
 
 const WORKSPACE_TREE_MAX_DEPTH = 3;
@@ -81,6 +88,7 @@ interface ResolvedDirectoryTreeOptions {
 	gitignore: boolean;
 	cache: boolean;
 	rootLabel: string;
+	childIndex: ReadonlyMap<string, ReadonlySet<string>> | null;
 }
 
 interface RenderLine {
@@ -122,6 +130,7 @@ function resolveDirectoryTreeOptions(options: DirectoryTreeOptions): ResolvedDir
 		gitignore: options.gitignore ?? false,
 		cache: options.cache ?? true,
 		rootLabel: options.rootLabel ?? ".",
+		childIndex: options.childIndex ?? null,
 	};
 }
 
@@ -157,6 +166,10 @@ async function listDirectChildNames(
 	parent: DirectoryTreeNode,
 	options: ResolvedDirectoryTreeOptions,
 ): Promise<string[]> {
+	if (options.childIndex) {
+		const names = options.childIndex.get(parent.relativePath);
+		return names ? Array.from(names) : [];
+	}
 	if (!options.gitignore) {
 		const directoryPath = parent.relativePath ? path.join(rootPath, parent.relativePath) : rootPath;
 		return await fs.readdir(directoryPath);
@@ -377,19 +390,96 @@ export async function buildDirectoryTree(rootPath: string, options: DirectoryTre
 	};
 }
 
+/**
+ * Build a `parentRelativePath` → child name index from a flat list of POSIX
+ * paths. Intermediate directory components are inferred from path segments;
+ * the index covers every ancestor directory implied by the input.
+ */
+function buildChildIndexFromPaths(paths: readonly string[]): Map<string, Set<string>> {
+	const index = new Map<string, Set<string>>();
+	const ensure = (parent: string): Set<string> => {
+		let bucket = index.get(parent);
+		if (!bucket) {
+			bucket = new Set<string>();
+			index.set(parent, bucket);
+		}
+		return bucket;
+	};
+	for (const raw of paths) {
+		if (!raw) continue;
+		const normalized = raw.replace(/\\/g, "/");
+		const parts = normalized.split("/").filter(segment => segment.length > 0);
+		if (parts.length === 0) continue;
+		for (let i = 0; i < parts.length; i += 1) {
+			const parent = parts.slice(0, i).join("/");
+			const segment = parts[i];
+			if (segment !== undefined) ensure(parent).add(segment);
+		}
+	}
+	return index;
+}
+
+const GIT_LS_FILES_TIMEOUT_MS = 3000;
+
+/**
+ * List tracked + untracked-not-ignored files at `rootPath` via `git ls-files`.
+ * Returns `null` when git is unavailable, the directory is not inside a
+ * worktree, or the call fails / times out — caller falls back to native
+ * directory listing.
+ */
+async function tryListGitFiles(rootPath: string): Promise<string[] | null> {
+	const gitPath = $which("git");
+	if (!gitPath) return null;
+	const signal = AbortSignal.timeout(GIT_LS_FILES_TIMEOUT_MS);
+	try {
+		const child = Bun.spawn([gitPath, "ls-files", "--cached", "--others", "--exclude-standard", "-z"], {
+			cwd: rootPath,
+			stdout: "pipe",
+			stderr: "pipe",
+			stdin: "ignore",
+			signal,
+		});
+		const [stdout, exitCode] = await Promise.all([
+			new Response(child.stdout as ReadableStream<Uint8Array>).text(),
+			child.exited,
+		]);
+		if (exitCode !== 0) return null;
+		if (!stdout) return [];
+		// `-z` separates entries with NUL; trailing NUL after final entry.
+		return stdout.split("\0").filter(entry => entry.length > 0);
+	} catch (error) {
+		logger.debug("git ls-files failed; falling back to native directory listing", {
+			rootPath,
+			error: error instanceof Error ? error.message : String(error),
+		});
+		return null;
+	}
+}
+
 export async function buildWorkspaceTree(cwd: string): Promise<WorkspaceTree> {
 	const rootPath = path.resolve(cwd);
+	const baseOptions = {
+		maxDepth: WORKSPACE_TREE_MAX_DEPTH,
+		directoryEntryLimit: WORKSPACE_TREE_DIR_LIMIT,
+		lineCap: WORKSPACE_TREE_LINE_CAP,
+		excludedDirectoryNames: WORKSPACE_TREE_EXCLUDED_DIRS,
+		hidden: false,
+		cache: true,
+		rootLabel: ".",
+	} satisfies DirectoryTreeOptions;
+
 	try {
-		return await buildDirectoryTree(rootPath, {
-			maxDepth: WORKSPACE_TREE_MAX_DEPTH,
-			directoryEntryLimit: WORKSPACE_TREE_DIR_LIMIT,
-			lineCap: WORKSPACE_TREE_LINE_CAP,
-			excludedDirectoryNames: WORKSPACE_TREE_EXCLUDED_DIRS,
-			hidden: false,
-			gitignore: true,
-			cache: true,
-			rootLabel: ".",
-		});
+		const gitFiles = await tryListGitFiles(rootPath);
+		if (gitFiles !== null) {
+			// Git already applied gitignore + tracking semantics: bypass native
+			// recursive scan and feed the index directly to the tree builder.
+			return await buildDirectoryTree(rootPath, {
+				...baseOptions,
+				gitignore: false,
+				childIndex: buildChildIndexFromPaths(gitFiles),
+			});
+		}
+		return await buildDirectoryTree(rootPath, { ...baseOptions, gitignore: true });
 	} catch {
 		return emptyWorkspaceTree(rootPath);
 	}