@oh-my-pi/pi-coding-agent 14.7.8 → 14.8.1

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`). */