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

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

@@ -1,94 +0,0 @@
-import type { Anchor, HashlineCursor } from "./types";
-/**
- * Split a hashline diff into individual lines without losing the trailing
- * empty line that callers may rely on for explicit blank payloads. CRLF pairs
- * are normalized to a single line break.
- *
- * This mirrors the line-splitting performed by {@link HashlineTokenizer}'s
- * streaming drain loop and is kept for non-streaming callers that prefer
- * a single-shot split.
- */
-export declare function splitHashlineLines(text: string): string[];
-export declare function cloneCursor(cursor: HashlineCursor): HashlineCursor;
-/** Parse a bare line-number anchor (used by insert ops). Throws on malformed input. */
-export declare function parseLid(raw: string, lineNum: number): Anchor;
-export interface ParsedRange {
-    start: Anchor;
-    end: Anchor;
-}
-/**
- * Returns true when the line scans as `LINE!payload` (delete sigil followed by
- * additional content). The executor uses this for the dedicated "deletes only"
- * diagnostic, separate from the standard "unrecognized op" path.
- */
-export declare function isDeleteOpWithPayload(line: string): boolean;
-interface TokenBase {
-    /** 1-indexed line number in the original input stream. */
-    lineNum: number;
-}
-export type HashlineToken = (TokenBase & {
-    kind: "blank";
-}) | (TokenBase & {
-    kind: "envelope-begin";
-}) | (TokenBase & {
-    kind: "envelope-end";
-}) | (TokenBase & {
-    kind: "abort";
-}) | (TokenBase & {
-    kind: "header";
-    path: string;
-    fileHash?: string;
-}) | (TokenBase & {
-    kind: "op-insert";
-    cursor: HashlineCursor;
-    inlineBody: string | undefined;
-}) | (TokenBase & {
-    kind: "op-replace";
-    range: ParsedRange;
-    inlineBody: string | undefined;
-}) | (TokenBase & {
-    kind: "op-delete";
-    range: ParsedRange;
-    trailingPayload: boolean;
-}) | (TokenBase & {
-    kind: "payload";
-    text: string;
-}) | (TokenBase & {
-    kind: "raw";
-    text: string;
-});
-/**
- * Stateful, line-oriented classifier for hashline diff text. Use the streaming
- * {@link feed}/{@link end} pair to ingest text in chunks (each completed line
- * emits exactly one token; a trailing partial line stays buffered until the
- * next chunk or {@link end}). Use the stateless {@link tokenize}/predicate
- * methods for callers that already hold whole lines and only need
- * classification without buffering.
- */
-export declare class HashlineTokenizer {
-    #private;
-    /**
-     * Ingest a chunk of input text. Each newline-terminated line in the
-     * combined buffer produces one token. A trailing partial line (no `\n`
-     * yet, possibly ending in a lone `\r`) stays buffered until the next
-     * `feed`/`end` call so CRLF pairs that straddle chunk boundaries are
-     * still normalized correctly.
-     */
-    feed(chunk: string): HashlineToken[];
-    /**
-     * Flush any buffered residual line (the last line of input when it lacks
-     * a trailing newline) and mark the tokenizer closed. Calling `end` a
-     * second time returns `[]`; reuse requires `reset`.
-     */
-    end(): HashlineToken[];
-    /** Discard any buffered text and reset the line counter to 1. */
-    reset(): void;
-    /** Convenience: feed an entire text and immediately flush. */
-    tokenizeAll(text: string): HashlineToken[];
-    /** Stateless one-shot classification. Does not touch the streaming buffer. */
-    tokenize(line: string, lineNum?: number): HashlineToken;
-    isOp(line: string): boolean;
-    isHeader(line: string): boolean;
-    isEnvelopeMarker(line: string): boolean;
-}
-export {};

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

@@ -1,75 +0,0 @@
-import * as z from "zod/v4";
-import type { LspBatchRequest } from "../edit/renderer";
-import type { WritethroughCallback, WritethroughDeferredHandle } from "../lsp";
-import type { ToolSession } from "../tools";
-export type Anchor = {
-    line: number;
-};
-export type HashlineCursor = {
-    kind: "bof";
-} | {
-    kind: "eof";
-} | {
-    kind: "before_anchor";
-    anchor: Anchor;
-} | {
-    kind: "after_anchor";
-    anchor: Anchor;
-};
-export type HashlineEdit = {
-    kind: "insert";
-    cursor: HashlineCursor;
-    text: string;
-    lineNum: number;
-    index: number;
-} | {
-    kind: "delete";
-    anchor: Anchor;
-    lineNum: number;
-    index: number;
-    oldAssertion?: string;
-};
-export interface HashlineInputSection {
-    path: string;
-    fileHash?: string;
-    diff: string;
-}
-/** `path` is accepted by the edit tool runtime; other extra keys are preserved. */
-export declare const hashlineEditParamsSchema: z.ZodObject<{
-    input: z.ZodString;
-    path: z.ZodOptional<z.ZodString>;
-}, z.core.$loose>;
-export type HashlineParams = z.infer<typeof hashlineEditParamsSchema>;
-export interface HashlineStreamOptions {
-    /** First line number to use when formatting (1-indexed). */
-    startLine?: number;
-    /** Maximum formatted lines per yielded chunk (default: 200). */
-    maxChunkLines?: number;
-    /** Maximum UTF-8 bytes per yielded chunk (default: 64 KiB). */
-    maxChunkBytes?: number;
-}
-export interface CompactHashlineDiffPreview {
-    preview: string;
-    addedLines: number;
-    removedLines: number;
-}
-export interface CompactHashlineDiffOptions {
-    /** Maximum entries kept on each side of an unchanged-context truncation (default: 2). */
-    maxUnchangedRun?: number;
-}
-export interface HashlineApplyOptions {
-    autoDropPureInsertDuplicates?: boolean;
-}
-export interface SplitHashlineOptions {
-    cwd?: string;
-    path?: string;
-}
-export interface ExecuteHashlineSingleOptions {
-    session: ToolSession;
-    input: string;
-    path?: string;
-    signal?: AbortSignal;
-    batchRequest?: LspBatchRequest;
-    writethrough: WritethroughCallback;
-    beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
-}

package/src/edit/file-read-cache.ts

@@ -1,138 +0,0 @@
-/**
- * Per-session cache of file contents as they were rendered to the model by
- * the `read` and `search` tools in the current agent session.
- *
- * Used by hashline-mode anchor-stale recovery: if the model authored anchors
- * against a version of the file that no longer matches what is on disk —
- * because a subagent, the user, a linter, or a formatter modified the file
- * between the read and the edit — we replay the edits against the cached
- * pre-edit snapshot and 3-way-merge the result onto the live file.
- *
- * Scoped per `ToolSession`: the cache lives on the session object itself, so
- * different sessions never share snapshots and entries get reclaimed when
- * the session goes out of scope. Each session keeps a small LRU window of
- * paths; each path keeps a short ring of recent snapshots so follow-up edits
- * can recover from the agent's own prior writes as well as stale reads.
- */
-import { LRUCache } from "lru-cache/raw";
-import type { ToolSession } from "../tools";
-
-const MAX_PATHS_PER_SESSION = 30;
-const MAX_SNAPSHOTS_PER_PATH = 4;
-
-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 class FileReadCache {
-	#snapshots = new LRUCache<string, FileReadSnapshot[]>({ max: MAX_PATHS_PER_SESSION });
-
-	/** Look up the most recent snapshot for `absPath`, or `null` if absent. */
-	get(absPath: string): FileReadSnapshot | null {
-		return this.#snapshots.get(absPath)?.[0] ?? null;
-	}
-
-	/** Look up the most recent snapshot for `absPath` whose file hash matches. */
-	getByHash(absPath: string, fileHash: string): FileReadSnapshot | null {
-		const history = this.#snapshots.get(absPath);
-		return history?.find(snapshot => snapshot.fileHash === fileHash) ?? 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 {
-		if (lines.length === 0 && metadata.fullText === undefined) return;
-		const entries: Array<readonly [number, string]> = lines.map((line, idx) => [startLine + idx, line] as const);
-		this.#record(absPath, entries, metadata);
-	}
-
-	/** Record sparse `(lineNumber, content)` pairs (e.g. `search` matches plus context). */
-	recordSparse(
-		absPath: string,
-		entries: Iterable<readonly [number, string]>,
-		metadata: FileReadSnapshotMetadata = {},
-	): void {
-		const arr = Array.from(entries);
-		if (arr.length === 0 && metadata.fullText === undefined) return;
-		this.#record(absPath, arr, metadata);
-	}
-
-	/** Drop the snapshot history for a single path. */
-	invalidate(absPath: string): void {
-		this.#snapshots.delete(absPath);
-	}
-
-	/** Drop every snapshot history. */
-	clear(): void {
-		this.#snapshots.clear();
-	}
-
-	#record(
-		absPath: string,
-		entries: ReadonlyArray<readonly [number, string]>,
-		metadata: FileReadSnapshotMetadata,
-	): void {
-		const history = this.#snapshots.get(absPath) ?? [];
-		const head = history[0];
-		const now = Date.now();
-		if (head && !hasConflict(head.lines, entries) && !hasHashConflict(head, metadata)) {
-			for (const [lineNum, content] of entries) head.lines.set(lineNum, content);
-			if (metadata.fullText !== undefined) head.fullText = metadata.fullText;
-			if (metadata.fileHash !== undefined) head.fileHash = metadata.fileHash;
-			head.recordedAt = now;
-			// `get` above already touched LRU recency for this key.
-			return;
-		}
-
-		const nextSnapshot: FileReadSnapshot = {
-			lines: new Map(entries),
-			...metadata,
-			recordedAt: now,
-		};
-		const dedupedHistory = history.filter(snapshot => !isSameSnapshotIdentity(snapshot, nextSnapshot));
-		this.#snapshots.set(absPath, [nextSnapshot, ...dedupedHistory].slice(0, MAX_SNAPSHOTS_PER_PATH));
-	}
-}
-
-function hasConflict(existing: Map<number, string>, incoming: ReadonlyArray<readonly [number, string]>): boolean {
-	for (const [lineNum, content] of incoming) {
-		const prior = existing.get(lineNum);
-		if (prior !== undefined && prior !== content) return true;
-	}
-	return false;
-}
-
-function hasHashConflict(existing: FileReadSnapshot, metadata: FileReadSnapshotMetadata): boolean {
-	return metadata.fileHash !== undefined && existing.fileHash !== undefined && metadata.fileHash !== existing.fileHash;
-}
-
-function isSameSnapshotIdentity(left: FileReadSnapshot, right: FileReadSnapshot): boolean {
-	if (left.fileHash !== undefined && right.fileHash !== undefined) return left.fileHash === right.fileHash;
-	if (left.fullText !== undefined && right.fullText !== undefined) return left.fullText === right.fullText;
-	return false;
-}
-
-/**
- * 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 function getFileReadCache(session: ToolSession): FileReadCache {
-	if (!session.fileReadCache) session.fileReadCache = new FileReadCache();
-	return session.fileReadCache;
-}

package/src/hashline/anchors.ts

@@ -1,104 +0,0 @@
-import { MISMATCH_CONTEXT } from "./constants";
-import { formatNumberedLine, HL_FILE_HASH_SEP, HL_FILE_PREFIX } from "./hash";
-
-const LINE_REF_RE = /^\s*[>+\-*]*\s*(\d+)(?::.*)?\s*$/;
-
-export function formatFullAnchorRequirement(raw?: string): string {
-	const received = raw === undefined ? "" : ` Received ${JSON.stringify(raw)}.`;
-	return (
-		`a bare line number from read/search output plus the section header file hash ` +
-		`(for example ${HL_FILE_PREFIX}src/foo.ts${HL_FILE_HASH_SEP}1a2b and line "160")${received}`
-	);
-}
-
-export function parseTag(ref: string): { line: number } {
-	const match = ref.match(LINE_REF_RE);
-	if (!match) {
-		throw new Error(`Invalid line reference. Expected ${formatFullAnchorRequirement(ref)}.`);
-	}
-	const line = Number.parseInt(match[1], 10);
-	if (line < 1) throw new Error(`Line number must be >= 1, got ${line} in "${ref}".`);
-	return { line };
-}
-
-export interface HashlineMismatchDetails {
-	path?: string;
-	expectedFileHash: string;
-	actualFileHash: string;
-	fileLines: string[];
-	anchorLines?: readonly number[];
-}
-
-function getMismatchDisplayLines(anchorLines: readonly number[], fileLines: string[]): number[] {
-	const displayLines = new Set<number>();
-	for (const line of anchorLines) {
-		if (line < 1 || line > fileLines.length) continue;
-		const lo = Math.max(1, line - MISMATCH_CONTEXT);
-		const hi = Math.min(fileLines.length, line + MISMATCH_CONTEXT);
-		for (let lineNum = lo; lineNum <= hi; lineNum++) displayLines.add(lineNum);
-	}
-	return [...displayLines].sort((a, b) => a - b);
-}
-
-export class HashlineMismatchError extends Error {
-	readonly path: string | undefined;
-	readonly expectedFileHash: string;
-	readonly actualFileHash: string;
-	readonly fileLines: string[];
-	readonly anchorLines: readonly number[];
-
-	constructor(details: HashlineMismatchDetails) {
-		super(HashlineMismatchError.formatMessage(details));
-		this.name = "HashlineMismatchError";
-		this.path = details.path;
-		this.expectedFileHash = details.expectedFileHash;
-		this.actualFileHash = details.actualFileHash;
-		this.fileLines = details.fileLines;
-		this.anchorLines = details.anchorLines ?? [];
-	}
-
-	get displayMessage(): string {
-		return HashlineMismatchError.formatDisplayMessage({
-			path: this.path,
-			expectedFileHash: this.expectedFileHash,
-			actualFileHash: this.actualFileHash,
-			fileLines: this.fileLines,
-			anchorLines: this.anchorLines,
-		});
-	}
-
-	static rejectionHeader(details: HashlineMismatchDetails): string[] {
-		const pathText = details.path ? ` for ${details.path}` : "";
-		return [
-			`Edit rejected${pathText}: file changed between read and edit.`,
-			`Section is bound to ${HL_FILE_HASH_SEP}${details.expectedFileHash}, but the current file hashes to ${HL_FILE_HASH_SEP}${details.actualFileHash}. If your previous edit in this session modified this file, copy the ${HL_FILE_PREFIX}path${HL_FILE_HASH_SEP}newhash from that edit's response. Otherwise re-read the file before retrying.`,
-		];
-	}
-
-	static formatDisplayMessage(details: HashlineMismatchDetails): string {
-		return HashlineMismatchError.formatMessage(details);
-	}
-
-	static formatMessage(details: HashlineMismatchDetails): string {
-		const anchorSet = new Set(details.anchorLines ?? []);
-		const lines = HashlineMismatchError.rejectionHeader(details);
-		const displayLines = getMismatchDisplayLines(details.anchorLines ?? [], details.fileLines);
-		if (displayLines.length === 0) return lines.join("\n");
-		lines.push("");
-		let previous = -1;
-		for (const lineNum of displayLines) {
-			if (previous !== -1 && lineNum > previous + 1) lines.push("...");
-			previous = lineNum;
-			const text = details.fileLines[lineNum - 1] ?? "";
-			const marker = anchorSet.has(lineNum) ? "*" : " ";
-			lines.push(`${marker}${formatNumberedLine(lineNum, text)}`);
-		}
-		return lines.join("\n");
-	}
-}
-
-export function validateLineRef(ref: { line: number }, fileLines: string[]): void {
-	if (ref.line < 1 || ref.line > fileLines.length) {
-		throw new Error(`Line ${ref.line} does not exist (file has ${fileLines.length} lines)`);
-	}
-}