@oh-my-pi/pi-coding-agent 15.5.2 → 15.5.4

package/src/tools/path-utils.ts

@@ -133,6 +133,87 @@ export function expandPath(filePath: string): string {
 	const normalized = stripFileUrl(normalizeUnicodeSpaces(normalizeAtPrefix(filePath)));
 	return expandTilde(normalized);
 }
+/**
+ * Inclusive line range describing one selector segment (e.g. `50-100`,
+ * `301-`, or `50+10`). `endLine` is `undefined` for open-ended ranges.
+ */
+export interface LineRange {
+	startLine: number;
+	endLine: number | undefined;
+}
+
+const LINE_RANGE_CHUNK_RE = /^L?(\d+)(?:([-+])L?(\d+)?)?$/i;
+
+/** Parse a single `N`, `N-M`, `N-`, or `N+K` chunk. Throws via {@link ToolError} on invalid bounds. */
+export function parseLineRangeChunk(sel: string): LineRange | null {
+	const lineMatch = LINE_RANGE_CHUNK_RE.exec(sel);
+	if (!lineMatch) return null;
+	const rawStart = Number.parseInt(lineMatch[1]!, 10);
+	if (rawStart < 1) {
+		throw new ToolError("Line selector 0 is invalid; lines are 1-indexed. Use :1.");
+	}
+	const sep = lineMatch[2];
+	const rhs = lineMatch[3] ? Number.parseInt(lineMatch[3], 10) : undefined;
+	let rawEnd: number | undefined;
+	if (sep === "+") {
+		if (rhs === undefined || rhs < 1) {
+			throw new ToolError(`Invalid range ${rawStart}+${rhs ?? 0}: count must be >= 1.`);
+		}
+		rawEnd = rawStart + rhs - 1;
+	} else if (sep === "-") {
+		// `301-` is shorthand for "from 301 onward" — equivalent to bare `301`.
+		if (rhs !== undefined) {
+			if (rhs < rawStart) {
+				throw new ToolError(`Invalid range ${rawStart}-${rhs}: end must be >= start.`);
+			}
+			rawEnd = rhs;
+		}
+	}
+	return { startLine: rawStart, endLine: rawEnd };
+}
+
+/**
+ * Parse a comma-separated list of line ranges (e.g. `5-16,960-973`). Returns
+ * the ranges in ascending order with overlapping/adjacent ranges merged so
+ * downstream consumers can stream the file in a single forward pass per range.
+ */
+export function parseLineRanges(sel: string): [LineRange, ...LineRange[]] | null {
+	const chunks = sel.split(",");
+	const parsed: LineRange[] = [];
+	for (const chunk of chunks) {
+		const range = parseLineRangeChunk(chunk);
+		if (!range) return null;
+		parsed.push(range);
+	}
+	if (parsed.length === 0) return null;
+	parsed.sort((a, b) => a.startLine - b.startLine);
+
+	const merged: LineRange[] = [parsed[0]];
+	for (let i = 1; i < parsed.length; i++) {
+		const current = parsed[i];
+		const last = merged[merged.length - 1];
+		// Open-ended (endLine undefined) means "to EOF" — any later range is absorbed.
+		if (last.endLine === undefined) continue;
+		// Merge when current starts within (or immediately after) the last range.
+		if (current.startLine <= last.endLine + 1) {
+			if (current.endLine === undefined || current.endLine > last.endLine) {
+				merged[merged.length - 1] = { startLine: last.startLine, endLine: current.endLine };
+			}
+			continue;
+		}
+		merged.push(current);
+	}
+	return merged as [LineRange, ...LineRange[]];
+}
+
+/** Return `true` when `lineNumber` (1-indexed) falls in any of the supplied ranges. */
+export function isLineInRanges(lineNumber: number, ranges: readonly LineRange[]): boolean {
+	for (const range of ranges) {
+		if (lineNumber < range.startLine) continue;
+		if (range.endLine === undefined || lineNumber <= range.endLine) return true;
+	}
+	return false;
+}
 
 export function splitPathAndSel(rawPath: string): { path: string; sel?: string } {
 	const colon = rawPath.lastIndexOf(":");

package/src/tools/read.ts

@@ -1,6 +1,7 @@
 import { Database } from "bun:sqlite";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { computeFileHash, formatHashlineHeader, formatNumberedLine, formatNumberedLines } from "@oh-my-pi/hashline";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
 import { glob, type SummaryResult, summarizeCode } from "@oh-my-pi/pi-natives";
@@ -8,11 +9,10 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { getRemoteDir, logger, prompt, readImageMetadata, untilAborted } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
-import { getFileReadCache } from "../edit/file-read-cache";
+import { getFileSnapshotStore } from "../edit/file-snapshot-store";
 import { normalizeToLF } from "../edit/normalize";
 import { isNotebookPath, readEditableNotebookText } from "../edit/notebook";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import { computeFileHash, formatHashlineHeader, formatNumberedLine, formatNumberedLines } from "../hashline/hash";
 import { InternalUrlRouter } from "../internal-urls";
 import { parseInternalUrl } from "../internal-urls/parse";
 import type { InternalUrl } from "../internal-urls/types";
@@ -66,6 +66,8 @@ import {
 import {
 	expandPath,
 	formatPathRelativeToCwd,
+	type LineRange,
+	parseLineRanges,
 	resolveReadPath,
 	splitInternalUrlSel,
 	splitPathAndSel,
@@ -145,7 +147,7 @@ function recordHashlineSnapshot(
 	context: HashlineHeaderContext | undefined,
 ): void {
 	if (!context || !absolutePath || !path.isAbsolute(absolutePath)) return;
-	getFileReadCache(session).recordContiguous(absolutePath, 1, context.fullText.split("\n"), {
+	getFileSnapshotStore(session).recordContiguous(absolutePath, 1, context.fullText.split("\n"), {
 		fullText: context.fullText,
 		fileHash: context.fileHash,
 	});
@@ -568,16 +570,12 @@ export interface ReadToolDetails {
 type ReadParams = ReadToolInput;
 
 /** Parsed representation of a path-embedded selector. */
-type LineRange = { startLine: number; endLine: number | undefined };
-
 type ParsedSelector =
 	| { kind: "none" }
 	| { kind: "raw" }
 	| { kind: "conflicts" }
 	| { kind: "lines"; ranges: [LineRange, ...LineRange[]]; raw?: boolean };
 
-const LINE_RANGE_RE = /^L?(\d+)(?:([-+])L?(\d+)?)?$/i;
-
 /** Returns true when the selector requested verbatim/raw output (alone or combined with a range). */
 function isRawSelector(parsed: ParsedSelector): boolean {
 	return parsed.kind === "raw" || (parsed.kind === "lines" && parsed.raw === true);
@@ -588,67 +586,6 @@ function isMultiRange(parsed: ParsedSelector): boolean {
 	return parsed.kind === "lines" && parsed.ranges.length > 1;
 }
 
-function parseLineRangeChunk(sel: string): LineRange | null {
-	const lineMatch = LINE_RANGE_RE.exec(sel);
-	if (!lineMatch) return null;
-	const rawStart = Number.parseInt(lineMatch[1]!, 10);
-	if (rawStart < 1) {
-		throw new ToolError("Line selector 0 is invalid; lines are 1-indexed. Use :1.");
-	}
-	const sep = lineMatch[2];
-	const rhs = lineMatch[3] ? Number.parseInt(lineMatch[3], 10) : undefined;
-	let rawEnd: number | undefined;
-	if (sep === "+") {
-		if (rhs === undefined || rhs < 1) {
-			throw new ToolError(`Invalid range ${rawStart}+${rhs ?? 0}: count must be >= 1.`);
-		}
-		rawEnd = rawStart + rhs - 1;
-	} else if (sep === "-") {
-		// `301-` is shorthand for "from 301 onward" — equivalent to bare `301`.
-		if (rhs !== undefined) {
-			if (rhs < rawStart) {
-				throw new ToolError(`Invalid range ${rawStart}-${rhs}: end must be >= start.`);
-			}
-			rawEnd = rhs;
-		}
-	}
-	return { startLine: rawStart, endLine: rawEnd };
-}
-
-/**
- * Parse a comma-separated list of line ranges (e.g. `5-16,960-973`). Returns
- * the ranges in ascending order with overlapping/adjacent ranges merged so
- * downstream consumers can stream the file in a single forward pass per range.
- */
-function parseLineRanges(sel: string): [LineRange, ...LineRange[]] | null {
-	const chunks = sel.split(",");
-	const parsed: LineRange[] = [];
-	for (const chunk of chunks) {
-		const range = parseLineRangeChunk(chunk);
-		if (!range) return null;
-		parsed.push(range);
-	}
-	if (parsed.length === 0) return null;
-	parsed.sort((a, b) => a.startLine - b.startLine);
-
-	const merged: LineRange[] = [parsed[0]];
-	for (let i = 1; i < parsed.length; i++) {
-		const current = parsed[i];
-		const last = merged[merged.length - 1];
-		// Open-ended (endLine undefined) means "to EOF" — any later range is absorbed.
-		if (last.endLine === undefined) continue;
-		// Merge when current starts within (or immediately after) the last range.
-		if (current.startLine <= last.endLine + 1) {
-			if (current.endLine === undefined || current.endLine > last.endLine) {
-				merged[merged.length - 1] = { startLine: last.startLine, endLine: current.endLine };
-			}
-			continue;
-		}
-		merged.push(current);
-	}
-	return merged as [LineRange, ...LineRange[]];
-}
-
 function parseSel(sel: string | undefined): ParsedSelector {
 	if (!sel || sel.length === 0) return { kind: "none" };
 
@@ -1122,7 +1059,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			}
 
 			if (collectedLines.length > 0) {
-				getFileReadCache(this.session).recordContiguous(
+				getFileSnapshotStore(this.session).recordContiguous(
 					absolutePath,
 					range.startLine,
 					collectedLines,
@@ -1406,14 +1343,19 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					? await bridgePromise.catch(() => Bun.file(absolutePath).text())
 					: await Bun.file(absolutePath).text();
 			throwIfAborted(signal);
-			if (countTextLines(code) > MAX_SUMMARY_LINES) return null;
+			const lineCount = countTextLines(code);
+			if (lineCount > MAX_SUMMARY_LINES) return null;
+			if (lineCount < this.session.settings.get("read.summarize.minTotalLines")) return null;
 
-			return summarizeCode({
+			const result = summarizeCode({
 				code,
 				path: absolutePath,
 				minBodyLines: this.session.settings.get("read.summarize.minBodyLines"),
 				minCommentLines: this.session.settings.get("read.summarize.minCommentLines"),
+				unfoldUntilLines: this.session.settings.get("read.summarize.unfoldUntil"),
+				unfoldLimitLines: this.session.settings.get("read.summarize.unfoldLimit"),
 			});
+			return result;
 		} catch {
 			return null;
 		}
@@ -1921,7 +1863,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 						: undefined;
 
 					if (collectedLines.length > 0 && !firstLineExceedsLimit) {
-						getFileReadCache(this.session).recordContiguous(
+						getFileSnapshotStore(this.session).recordContiguous(
 							absolutePath,
 							startLineDisplay,
 							collectedLines,

package/src/tools/search.ts

@@ -1,15 +1,15 @@
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdtemp, rm, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import * as path from "node:path";
+import { computeFileHash, formatHashlineHeader } from "@oh-my-pi/hashline";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { type GrepMatch, GrepOutputMode, type GrepResult, grep } from "@oh-my-pi/pi-natives";
 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 * as z from "zod/v4";
-import { getFileReadCache } from "../edit/file-read-cache";
+import { getFileSnapshotStore } from "../edit/file-snapshot-store";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import { computeFileHash, formatHashlineHeader } from "../hashline/hash";
 import type { Theme } from "../modes/theme/theme";
 import searchDescription from "../prompts/tools/search.md" with { type: "text" };
 import { DEFAULT_MAX_COLUMN, type TruncationResult, truncateHead } from "../session/streaming-output";
@@ -26,7 +26,15 @@ import { createFileRecorder, formatResultPath } from "./file-recorder";
 import { formatGroupedFiles } from "./grouped-file-output";
 import { formatMatchLine } from "./match-line-format";
 import { formatFullOutputReference, type OutputMeta } from "./output-meta";
-import { resolveReadPath, resolveToolSearchScope } from "./path-utils";
+import {
+	hasGlobPathChars,
+	isLineInRanges,
+	type LineRange,
+	parseLineRanges,
+	resolveReadPath,
+	resolveToolSearchScope,
+	splitPathAndSel,
+} from "./path-utils";
 import {
 	createCachedComponent,
 	formatCodeFrameLine,
@@ -39,13 +47,19 @@ import {
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
-const searchPathEntrySchema = z.string().describe("file, directory, glob, or internal URL to search");
+const searchPathEntrySchema = z
+	.string()
+	.describe(
+		'file, directory, glob, internal URL, or "<file>:<lines>" selector (e.g. "src/foo.ts:50-100", "src/foo.ts:50+10", "src/foo.ts:50-100,200-300")',
+	);
 const searchSchema = z
 	.object({
 		pattern: z.string().describe("regex pattern"),
 		paths: z
 			.union([searchPathEntrySchema, z.array(searchPathEntrySchema).min(1)])
-			.describe("file, directory, glob, internal URL, or array of those to search"),
+			.describe(
+				"file, directory, glob, internal URL, or array of those to search; append `:<lines>` to scope a file to specific line ranges",
+			),
 		i: z.boolean().optional().describe("case-insensitive search"),
 		gitignore: z.boolean().optional().describe("respect gitignore"),
 		skip: z
@@ -98,6 +112,61 @@ function containsTopLevelComma(entry: string): boolean {
 	return false;
 }
 
+/**
+ * Parsed `paths` entry — a path (possibly archive-shaped) plus an optional
+ * line-range selector peeled off the trailing `:N-M` (or `:N+K`, `:N,M`, …)
+ * chunk via {@link splitPathAndSel}.
+ */
+interface SearchPathSpec {
+	original: string;
+	clean: string;
+	ranges?: [LineRange, ...LineRange[]];
+}
+
+function parsePathSpecs(rawEntries: readonly string[]): SearchPathSpec[] {
+	const specs: SearchPathSpec[] = [];
+	for (const entry of rawEntries) {
+		const split = splitPathAndSel(entry);
+		let clean = entry;
+		let ranges: [LineRange, ...LineRange[]] | undefined;
+		if (split.sel) {
+			const parsed = parseLineRanges(split.sel);
+			if (!parsed) {
+				throw new ToolError(
+					`paths entry "${entry}" — only line-range selectors like ":50-100" are supported (no ":raw"/":conflicts")`,
+				);
+			}
+			if (hasGlobPathChars(split.path)) {
+				throw new ToolError(`Line-range selector requires a single file, not a glob: ${entry}`);
+			}
+			clean = split.path;
+			ranges = parsed;
+		}
+		if (containsTopLevelComma(clean)) {
+			throw new ToolError('paths is an array — pass ["a", "b"] not ["a,b"]');
+		}
+		specs.push({ original: entry, clean, ranges });
+	}
+	return specs;
+}
+
+function mergeRangesInto(map: Map<string, LineRange[]>, absKey: string, ranges: readonly LineRange[]): void {
+	// Concat-without-merge is correct: `isLineInRanges` scans linearly, so
+	// duplicates/overlaps only cost a few extra comparisons per match.
+	const existing = map.get(absKey);
+	if (existing) {
+		existing.push(...ranges);
+	} else {
+		map.set(absKey, [...ranges]);
+	}
+}
+
+function matchAbsolutePath(matchPath: string, searchPath: string): string {
+	if (matchPath === "") return searchPath;
+	if (path.isAbsolute(matchPath)) return matchPath;
+	return path.resolve(searchPath, matchPath);
+}
+
 /**
  * Pre-resolve any `paths` entries that point at a member inside an archive
  * (e.g. `bundle.zip:src/foo.ts`, `release.tar.gz:notes.md`). Native grep
@@ -253,12 +322,9 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 			if (normalizedSkip < 0 || !Number.isFinite(normalizedSkip)) {
 				throw new ToolError("Skip must be a non-negative number");
 			}
-			const paths = toPathList(rawPaths);
-			for (const entry of paths) {
-				if (containsTopLevelComma(entry)) {
-					throw new ToolError('paths is an array — pass ["a", "b"] not ["a,b"]');
-				}
-			}
+			const rawEntries = toPathList(rawPaths);
+			const pathSpecs = parsePathSpecs(rawEntries);
+			const paths = pathSpecs.map(spec => spec.clean);
 			const {
 				resolvedPaths,
 				displayMap: archiveDisplayMap,
@@ -267,6 +333,33 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 				cleanup: cleanupArchiveScratch,
 			} = await resolveArchiveSearchPaths(paths, this.session.cwd);
 			try {
+				// Build the per-file line-range filter (keyed by absolute path) now that
+				// archive entries have been materialized to scratch files. Plain entries
+				// resolve through `resolveReadPath`; archive entries are keyed by the
+				// scratch path that grep will actually report against.
+				const rangesByAbsPath = new Map<string, LineRange[]>();
+				for (let idx = 0; idx < pathSpecs.length; idx++) {
+					const spec = pathSpecs[idx];
+					if (!spec.ranges) continue;
+					const resolved = resolvedPaths[idx];
+					if (resolved === spec.clean && !archiveDisplayMap.has(resolved)) {
+						// Non-archive entry; ensure the cleaned path resolves to a regular file.
+						const absKey = path.resolve(resolveReadPath(spec.clean, this.session.cwd));
+						const stats = await stat(absKey).catch(() => null);
+						if (!stats) {
+							throw new ToolError(`Path not found for line-range selector: ${spec.original}`);
+						}
+						if (!stats.isFile()) {
+							throw new ToolError(`Line-range selector requires a single file: ${spec.original} is a directory`);
+						}
+						mergeRangesInto(rangesByAbsPath, absKey, spec.ranges);
+					} else {
+						// Archive entry — `resolveArchiveSearchPaths` substituted a scratch path.
+						const absKey = path.resolve(resolved);
+						mergeRangesInto(rangesByAbsPath, absKey, spec.ranges);
+					}
+				}
+
 				if (archiveUnreadable.length > 0 && resolvedPaths.length === archiveUnreadable.length) {
 					// All inputs were archive selectors we couldn't materialize; surface the
 					// reason instead of a downstream "path not found" from the scope resolver.
@@ -390,12 +483,38 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 					}
 					throw err;
 				}
+				if (rangesByAbsPath.size > 0) {
+					const filteredMatches: GrepMatch[] = [];
+					for (const match of result.matches) {
+						const abs = matchAbsolutePath(match.path, searchPath);
+						const ranges = rangesByAbsPath.get(abs);
+						if (!ranges) {
+							// Path has no line-range constraint (e.g. a peer entry without `:N-M`).
+							filteredMatches.push(match);
+							continue;
+						}
+						if (!isLineInRanges(match.lineNumber, ranges)) continue;
+						// Drop context lines that fall outside the allowed ranges; they would
+						// otherwise leak content the caller explicitly excluded.
+						const trimBefore = match.contextBefore?.filter(c => isLineInRanges(c.lineNumber, ranges));
+						const trimAfter = match.contextAfter?.filter(c => isLineInRanges(c.lineNumber, ranges));
+						filteredMatches.push({
+							...match,
+							contextBefore: trimBefore && trimBefore.length > 0 ? trimBefore : undefined,
+							contextAfter: trimAfter && trimAfter.length > 0 ? trimAfter : undefined,
+						});
+					}
+					result = {
+						matches: filteredMatches,
+						totalMatches: filteredMatches.length,
+						filesWithMatches: new Set(filteredMatches.map(match => match.path)).size,
+						filesSearched: result.filesSearched,
+						limitReached: result.limitReached,
+					};
+				}
 				if (archiveDisplayMap.size > 0) {
 					for (const match of result.matches) {
-						let abs: string;
-						if (match.path === "") abs = searchPath;
-						else if (path.isAbsolute(match.path)) abs = match.path;
-						else abs = path.resolve(searchPath, match.path);
+						const abs = matchAbsolutePath(match.path, searchPath);
 						const display = archiveDisplayMap.get(abs);
 						if (display) match.path = display;
 					}
@@ -552,7 +671,7 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 						fileMatchCounts.set(relativePath, (fileMatchCounts.get(relativePath) ?? 0) + 1);
 					}
 					if (cacheEntries.length > 0 && hashContext) {
-						getFileReadCache(this.session).recordSparse(hashContext.absolutePath, cacheEntries, {
+						getFileSnapshotStore(this.session).recordSparse(hashContext.absolutePath, cacheEntries, {
 							fileHash: hashContext.fileHash,
 						});
 					}

package/src/tools/write.ts

@@ -1,12 +1,12 @@
 import { Database } from "bun:sqlite";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { stripHashlinePrefixes } from "@oh-my-pi/hashline";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { isEnoent, isRecord, prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
-import { stripHashlinePrefixes } from "../edit";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { InternalUrlRouter } from "../internal-urls";
 import { parseInternalUrl } from "../internal-urls/parse";
@@ -487,7 +487,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 		const batchRequest = getLspBatchRequest(context?.toolCall);
 		const diagnostics = await this.#writethrough(absolutePath, newContent, signal, undefined, batchRequest);
 		invalidateFsScanAfterWrite(absolutePath);
-		this.session.fileReadCache?.invalidate(absolutePath);
+		this.session.fileSnapshotStore?.invalidate(absolutePath);
 		this.session.conflictHistory?.invalidate(entry.id);
 
 		const range =
@@ -609,7 +609,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 
 			const diagnostics = await this.#writethrough(absolutePath, text, signal, undefined, batchRequest);
 			invalidateFsScanAfterWrite(absolutePath);
-			this.session.fileReadCache?.invalidate(absolutePath);
+			this.session.fileSnapshotStore?.invalidate(absolutePath);
 			for (const entry of fileEntries) history.invalidate(entry.id);
 			succeededFiles.push({ displayPath: sample.displayPath, count: fileEntries.length });
 			totalResolvedIds += fileEntries.length;

package/src/utils/changelog.ts

@@ -8,10 +8,18 @@ export interface ChangelogEntry {
 }
 
 /**
- * Parse changelog entries from CHANGELOG.md
- * Scans for ## lines and collects content until next ## or EOF
+ * Parse changelog entries from the file at `changelogPath`. Scans for `## [x.y.z]`
+ * headings and collects each block until the next heading or EOF.
+ *
+ * Returns `[]` when `changelogPath` is `undefined` (package directory not
+ * resolvable — see `getChangelogPath`) or the file is missing. Callers MUST NOT
+ * synthesize a fallback path from the host project's cwd; doing so caused issue
+ * #1423 (the host project's `CHANGELOG.md` was rendered as omp's).
  */
-export async function parseChangelog(changelogPath: string): Promise<ChangelogEntry[]> {
+export async function parseChangelog(changelogPath: string | undefined): Promise<ChangelogEntry[]> {
+	if (!changelogPath) {
+		return [];
+	}
 	try {
 		const content = await Bun.file(changelogPath).text();
 		const lines = content.split("\n");

package/src/utils/file-mentions.ts

@@ -7,12 +7,12 @@
  */
 import * as fs from "node:fs/promises";
 import path from "node:path";
+import { computeFileHash, formatHashlineHeader, formatNumberedLines } from "@oh-my-pi/hashline";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 import { glob } from "@oh-my-pi/pi-natives";
 import { fuzzyMatch } from "@oh-my-pi/pi-tui";
 import { formatAge, formatBytes, readImageMetadata } from "@oh-my-pi/pi-utils";
-import { computeFileHash, formatHashlineHeader, formatNumberedLines } from "../hashline/hash";
 import type { FileMentionMessage } from "../session/messages";
 import {
 	DEFAULT_MAX_BYTES,

package/dist/types/edit/file-read-cache.d.ts

@@ -1,36 +0,0 @@
-import type { ToolSession } from "../tools";
-export interface FileReadSnapshot {
-    /** 1-indexed line number → exact line content as observed by `read`/`search`. */
-    lines: Map<number, string>;
-    /** Full normalized text when the read path observed the whole file. */
-    fullText?: string;
-    /** 4-hex hash of `fullText`, or a sparse snapshot hash supplied by search. */
-    fileHash?: string;
-    recordedAt: number;
-}
-interface FileReadSnapshotMetadata {
-    fullText?: string;
-    fileHash?: string;
-}
-export declare class FileReadCache {
-    #private;
-    /** Look up the most recent snapshot for `absPath`, or `null` if absent. */
-    get(absPath: string): FileReadSnapshot | null;
-    /** Look up the most recent snapshot for `absPath` whose file hash matches. */
-    getByHash(absPath: string, fileHash: string): FileReadSnapshot | null;
-    /** Record a contiguous run of lines (e.g. from a `read` tool). `startLine` is 1-indexed. */
-    recordContiguous(absPath: string, startLine: number, lines: readonly string[], metadata?: FileReadSnapshotMetadata): void;
-    /** Record sparse `(lineNumber, content)` pairs (e.g. `search` matches plus context). */
-    recordSparse(absPath: string, entries: Iterable<readonly [number, string]>, metadata?: FileReadSnapshotMetadata): void;
-    /** Drop the snapshot history for a single path. */
-    invalidate(absPath: string): void;
-    /** Drop every snapshot history. */
-    clear(): void;
-}
-/**
- * Look up (or lazily create) the file-read cache attached to a session. The
- * cache is stored as `session.fileReadCache` so it lives exactly as long as
- * the session itself.
- */
-export declare function getFileReadCache(session: ToolSession): FileReadCache;
-export {};

package/dist/types/hashline/anchors.d.ts

@@ -1,26 +0,0 @@
-export declare function formatFullAnchorRequirement(raw?: string): string;
-export declare function parseTag(ref: string): {
-    line: number;
-};
-export interface HashlineMismatchDetails {
-    path?: string;
-    expectedFileHash: string;
-    actualFileHash: string;
-    fileLines: string[];
-    anchorLines?: readonly number[];
-}
-export declare class HashlineMismatchError extends Error {
-    readonly path: string | undefined;
-    readonly expectedFileHash: string;
-    readonly actualFileHash: string;
-    readonly fileLines: string[];
-    readonly anchorLines: readonly number[];
-    constructor(details: HashlineMismatchDetails);
-    get displayMessage(): string;
-    static rejectionHeader(details: HashlineMismatchDetails): string[];
-    static formatDisplayMessage(details: HashlineMismatchDetails): string;
-    static formatMessage(details: HashlineMismatchDetails): string;
-}
-export declare function validateLineRef(ref: {
-    line: number;
-}, fileLines: string[]): void;

package/dist/types/hashline/apply.d.ts

@@ -1,14 +0,0 @@
-import type { HashlineApplyOptions, HashlineEdit } from "./types";
-export interface HashlineApplyResult {
-    lines: string;
-    firstChangedLine?: number;
-    warnings?: string[];
-    noopEdits?: HashlineNoopEdit[];
-}
-export interface HashlineNoopEdit {
-    editIndex: number;
-    loc: string;
-    reason: string;
-    current: string;
-}
-export declare function applyHashlineEdits(text: string, edits: HashlineEdit[], options?: HashlineApplyOptions): HashlineApplyResult;

package/dist/types/hashline/constants.d.ts

@@ -1,40 +0,0 @@
-/** Lines of context shown either side of a hash mismatch. */
-export declare const MISMATCH_CONTEXT = 2;
-/** Optional patch envelope start marker; silently consumed when present. */
-export declare const BEGIN_PATCH_MARKER = "*** Begin Patch";
-/** Optional patch envelope end marker; terminates parsing when encountered. */
-export declare const END_PATCH_MARKER = "*** End Patch";
-/**
- * Recovery sentinel emitted by the agent loop when a contaminated
- * `to=functions.edit` stream is truncated mid-call (see
- * `docs/ERRATA-GPT5-HARMONY.md`). Behaves like `END_PATCH_MARKER` for
- * parsing — terminates the line loop — and additionally surfaces a
- * warning in the tool result so the model knows to re-issue any
- * remaining edits.
- */
-export declare const ABORT_MARKER = "*** Abort";
-/** Warning text appended to the tool result when ABORT_MARKER terminates parsing. */
-export declare const ABORT_WARNING = "Tool stream truncated mid-call due to detected output corruption. Applied ops above are valid. Re-issue any remaining edits.";
-/**
- * Warning text appended when two consecutive `A-B:` ops on the exact same
- * range get coalesced (model painted a before/after pair). The second op
- * wins; the first op's payload is silently discarded.
- */
-export declare const REPLACE_PAIR_COALESCED_WARNING = "Detected an identical-range before/after replace pair; kept only the second block's payload. Issue ONE op per range \u2014 the payload is the final desired content, never both old and new.";
-/**
- * Warning text appended when un-prefixed continuation lines are accepted as
- * implicit payload (lenient legacy behavior). The model authored a multi-line
- * replace without `+` prefixes; the parser accepted it because the lines did
- * not classify as ops/headers/payloads, but the canonical syntax requires `+`
- * on every continuation line after the op.
- */
-export declare const IMPLICIT_CONTINUATION_WARNING = "Accepted continuation line(s) without the `+` prefix as implicit payload. Canonical syntax is `A-B:` followed by `+` on every continuation row; without `+`, lines that look like ops will be parsed as new ops instead of payload. Prefer the explicit form.";
-/**
- * Warning text appended when an inner `LINE:TEXT` (or sub-range `A-B:TEXT`)
- * op arrives while an outer `A-B:` replace is still pending and the inner
- * anchor falls inside the outer range. The model used the read-output
- * `LINE:TEXT` format as if it were a payload-continuation line; we strip the
- * `LINE:` prefix and append the body to the pending payload, but warn so the
- * canonical `+`-continuation form remains preferred.
- */
-export declare const PAYLOAD_LINE_PREFIX_DEMOTED_WARNING = "Detected one or more `LINE:TEXT` lines whose anchors fell inside a pending replace range; treated them as payload-continuation lines and stripped the `LINE:` prefix. Inside a multi-line `A-B:` block, payload lines after the first should be prefixed with `+` \u2014 never reuse the read-output gutter format.";

package/dist/types/hashline/diff-preview.d.ts

@@ -1,2 +0,0 @@
-import type { CompactHashlineDiffOptions, CompactHashlineDiffPreview } from "./types";
-export declare function buildCompactHashlineDiffPreview(diff: string, _options?: CompactHashlineDiffOptions): CompactHashlineDiffPreview;