@oh-my-pi/pi-coding-agent 15.5.3 → 15.5.6

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,48 +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 an `A-B:` block, every payload line must be on its own row prefixed with `+` \u2014 never reuse the read-output gutter format.";
-/**
- * Warning text appended when an op carries an inline payload (`LINE:TEXT`,
- * `A-B:TEXT`, `LINE↑TEXT`, `LINE↓TEXT`). Canonical syntax is bare op +
- * `+`-prefixed continuation rows; we accept the inline form leniently so the
- * model's first-attempt edit still lands, but warn so the canonical form
- * remains preferred.
- */
-export declare const INLINE_PAYLOAD_ACCEPTED_WARNING = "Accepted inline payload on the op line (e.g. `LINE:CONTENT`, `LINE\u2191CONTENT`). Canonical syntax is the bare op followed by `+`-prefixed payload rows on the next line(s). Prefer the explicit form.";

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;

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

@@ -1,16 +0,0 @@
-import type { HashlineApplyOptions, HashlineInputSection } from "./types";
-export declare function computeHashlineSectionDiff(section: HashlineInputSection, cwd: string, options?: HashlineApplyOptions): Promise<{
-    diff: string;
-    firstChangedLine: number | undefined;
-} | {
-    error: string;
-}>;
-export declare function computeHashlineDiff(input: {
-    input: string;
-    path?: string;
-}, cwd: string, options?: HashlineApplyOptions): Promise<{
-    diff: string;
-    firstChangedLine: number | undefined;
-} | {
-    error: string;
-}>;

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

@@ -1,4 +0,0 @@
-import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import type { EditToolDetails } from "../edit/renderer";
-import type { ExecuteHashlineSingleOptions, hashlineEditParamsSchema } from "./types";
-export declare function executeHashlineSingle(options: ExecuteHashlineSingleOptions): Promise<AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema>>;

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

@@ -1,56 +0,0 @@
-import { type HashlineToken } from "./tokenizer";
-import type { HashlineEdit } from "./types";
-/**
- * Token-driven state machine that turns a stream of {@link HashlineToken}s
- * into the flat list of {@link HashlineEdit}s applied downstream by the
- * apply/diff layers.
- *
- * The executor owns:
- *   - the running edit index (kept monotonic across pending flushes),
- *   - the pending-payload buffer (lines accumulated for the most recently
- *     opened insert/replace op),
- *   - all parse-time diagnostics (range order, "delete with payload",
- *     orphan payload, unrecognized op),
- *   - the {@link terminated} flag set by `envelope-end`/`abort`.
- *
- * Tokens are dispatched in the order they arrive; the matching tokenizer
- * supplies the line numbers carried inside each token so diagnostics line
- * up with the source.
- */
-export declare class HashlineExecutor {
-    #private;
-    /** True once an `envelope-end` or `abort` token has been observed. */
-    get terminated(): boolean;
-    /**
-     * Consume one token. After `terminated` flips true subsequent feeds
-     * are silently ignored so callers can keep draining their tokenizer
-     * without explicit early-exit guards.
-     */
-    feed(token: HashlineToken): void;
-    /**
-     * Flush any open pending op (with its full accumulated payload, including
-     * explicit `+` blank lines) and return the accumulated edits and warnings.
-     * The executor is single-use; reset() is required for reuse.
-     * Throws if two replace/delete ops target the same line with non-identical
-     * shapes (different ranges, replace+delete, delete+delete). Identical-range
-     * `A-B:` pairs in the same hunk are coalesced last-wins by `feed()` with a
-     * warning, so they never reach the validator.
-     */
-    end(): {
-        edits: HashlineEdit[];
-        warnings: string[];
-    };
-    /** Reset to a fresh state so the same instance can drive another parse. */
-    reset(): void;
-}
-/**
- * Drive a full hashline diff through the tokenizer + executor pipeline and
- * return the resulting edits plus any parse-time warnings. This is the
- * convenience entry point most callers want; reach for {@link
- * HashlineTokenizer}/{@link HashlineExecutor} directly only when you need
- * streaming feeds, cross-section state, or custom token handling.
- */
-export declare function parseHashline(diff: string): {
-    edits: HashlineEdit[];
-    warnings: string[];
-};

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

@@ -1,76 +0,0 @@
-/**
- * Core hash utilities shared by hashline edit mode, read/search output,
- * and prompt helpers.
- */
-/**
- * Decoration prefix that may precede a line number in tool output:
- * `>` (context line in grep), `-` (removed line), `*` (match line).
- * Any combination, in any order, surrounded by optional
- * whitespace. Output formatters emit at most one decoration per line; the
- * parser stays liberal because it accepts whatever the model echoes back.
- */
-export declare const HL_ANCHOR_DECORATION_RE_RAW = "\\s*[>\\-*]*\\s*";
-/** Capture-group regex source for a decorated bare line-number anchor. */
-export declare const HL_ANCHOR_RE_RAW = "\\s*[>\\-*]*\\s*(\\d+)";
-/** Bare positive line-number Lid (no decorations, no captures, no anchors). */
-export declare const HL_LINE_RE_RAW = "[1-9]\\d*";
-/** Capture-group form of {@link HL_LINE_RE_RAW}. */
-export declare const HL_LINE_CAPTURE_RE_RAW = "([1-9]\\d*)";
-/** Four-hex-character file hash carried by a hashline section header. */
-export declare const HL_FILE_HASH_RE_RAW = "[0-9a-f]{4}";
-/** Capture-group form of {@link HL_FILE_HASH_RE_RAW}. */
-export declare const HL_FILE_HASH_CAPTURE_RE_RAW = "([0-9a-f]{4})";
-/** Separator between a hashline file path and its file hash. */
-export declare const HL_FILE_HASH_SEP = "#";
-/** Separator between a line number and displayed line content in hashline mode. */
-export declare const HL_LINE_BODY_SEP = ":";
-/** Regex-escaped form of {@link HL_LINE_BODY_SEP}, safe for embedding inside a regex. */
-export declare const HL_LINE_BODY_SEP_RE_RAW: string;
-/**
- * Representative file hashes for use in user-facing error messages and prompt
- * examples.
- */
-export declare const HL_FILE_HASH_EXAMPLES: readonly ["1a2b", "3c4d", "9f3e"];
-/**
- * Format a comma-separated list of example anchors with an optional line-number
- * prefix, quoted for inclusion in error messages: `"160", "42", "7"`.
- */
-export declare function describeAnchorExamples(linePrefix?: string): string;
-/**
- * Substitute every grammar placeholder with the value derived from its
- * TypeScript counterpart. Grammars that don't reference these placeholders
- * pass through unchanged.
- */
-export declare function resolveHashlineGrammarPlaceholders(grammar: string): string;
-/**
- * op lines have an `ANCHOR<SIGIL>[INLINE_PAYLOAD]` shape, where SIGIL is one of
- * {@link HL_OP_INSERT_BEFORE}, {@link HL_OP_INSERT_AFTER}, {@link HL_OP_REPLACE},
- * or {@link HL_OP_DELETE}. Multi-line payloads follow on subsequent lines
- * prefixed with {@link HL_PAYLOAD_PREFIX}; that prefix is stripped before the
- * payload is written.
- *
- * These constants are the single source of truth for the edit parser, grammar,
- * renderer, and prompt.
- */
-export declare const HL_OP_INSERT_BEFORE = "\u2191";
-export declare const HL_OP_INSERT_AFTER = "\u2193";
-export declare const HL_OP_REPLACE = ":";
-export declare const HL_OP_DELETE = "!";
-/** Prefix for payload continuation lines. The prefix itself is not written. */
-export declare const HL_PAYLOAD_PREFIX = "+";
-/** All hashline edit op sigils, concatenated for fast membership tests. */
-export declare const HL_OP_CHARS = "\u2191\u2193:!";
-/** Hashline edit file section header marker. */
-export declare const HL_FILE_PREFIX = "\u00B6";
-/**
- * Compute the 4-hex-character hash carried by a hashline section header.
- * The hash normalizes CR characters and trailing whitespace before hashing so
- * platform line endings and display-trimmed lines do not invalidate anchors.
- */
-export declare function computeFileHash(text: string): string;
-/** Format a hashline section header for a file path and file hash. */
-export declare function formatHashlineHeader(filePath: string, fileHash: string): string;
-/** Formats a single numbered line as `LINE:TEXT`. */
-export declare function formatNumberedLine(lineNumber: number, line: string): string;
-/** Format file text with hashline-mode line-number prefixes for display. */
-export declare function formatNumberedLines(text: string, startLine?: number): string;

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

@@ -1,14 +0,0 @@
-export * from "./anchors";
-export * from "./apply";
-export * from "./constants";
-export * from "./diff";
-export * from "./diff-preview";
-export * from "./execute";
-export * from "./executor";
-export * from "./hash";
-export * from "./input";
-export * from "./prefixes";
-export * from "./recovery";
-export * from "./stream";
-export * from "./tokenizer";
-export * from "./types";

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

@@ -1,4 +0,0 @@
-import type { HashlineInputSection, SplitHashlineOptions } from "./types";
-export declare function containsRecognizableHashlineOperations(input: string): boolean;
-export declare function splitHashlineInput(input: string, options?: SplitHashlineOptions): HashlineInputSection;
-export declare function splitHashlineInputs(input: string, options?: SplitHashlineOptions): HashlineInputSection[];

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

@@ -1,7 +0,0 @@
-export declare function stripNewLinePrefixes(lines: string[]): string[];
-export declare function stripHashlinePrefixes(lines: string[]): string[];
-/**
- * Normalize line payloads by stripping read/search line prefixes. `null` /
- * `undefined` yield `[]`; a single multiline string is split on `\n`.
- */
-export declare function hashlineParseText(edit: string[] | string | null | undefined): string[];

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

@@ -1,21 +0,0 @@
-import type { FileReadCache } from "../edit/file-read-cache";
-import type { HashlineApplyOptions, HashlineEdit } from "./types";
-export interface HashlineRecoveryArgs {
-    cache: FileReadCache;
-    absolutePath: string;
-    currentText: string;
-    fileHash: string;
-    edits: HashlineEdit[];
-    options: HashlineApplyOptions;
-}
-export interface HashlineRecoveryResult {
-    lines: string;
-    firstChangedLine: number | undefined;
-    warnings: string[];
-}
-/**
- * Attempt to recover from a section file-hash mismatch by replaying the edits
- * against a cached pre-edit snapshot of the file and 3-way-merging the result
- * onto the current on-disk content. Returns `null` when no recovery is possible.
- */
-export declare function tryRecoverHashlineWithCache(args: HashlineRecoveryArgs): HashlineRecoveryResult | null;

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

@@ -1,2 +0,0 @@
-import type { HashlineStreamOptions } from "./types";
-export declare function streamHashLinesFromUtf8(source: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>, options?: HashlineStreamOptions): AsyncGenerator<string>;