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

package/src/hashline/prefixes.ts

@@ -1,111 +0,0 @@
-const HL_PREFIX_RE = /^\s*(?:>>>|>>)?\s*(?:[+*-]\s*)?\d+:/;
-const HL_PREFIX_PLUS_RE = /^\s*(?:>>>|>>)?\s*\+\s*\d+:/;
-const HL_HEADER_RE = /^\s*¶\S+#[0-9a-f]{4}\s*$/;
-const DIFF_PLUS_RE = /^[+](?![+])/;
-const READ_TRUNCATION_NOTICE_RE = /^\[(?:Showing lines \d+-\d+ of \d+|\d+ more lines? in (?:file|\S+))\b.*\bUse :L?\d+/;
-
-function stripLeadingHashlinePrefixes(line: string): string {
-	let result = line;
-	let previous: string;
-	do {
-		previous = result;
-		result = result.replace(HL_PREFIX_RE, "");
-	} while (result !== previous);
-	return result;
-}
-
-// ───────────────────────────────────────────────────────────────────────────
-// 5. Read-output prefix stripping
-//
-// When a model echoes back content from a `read` or `search` response, every
-// line is prefixed with either a hashline-mode line number (`123:`) or, for
-// diff-style echoes, a leading `+`. These helpers detect that and recover the
-// raw text.
-// ───────────────────────────────────────────────────────────────────────────
-
-type LinePrefixStats = {
-	nonEmpty: number;
-	headerCount: number;
-	hashPrefixCount: number;
-	diffPlusHashPrefixCount: number;
-	diffPlusCount: number;
-	truncationNoticeCount: number;
-};
-
-function collectLinePrefixStats(lines: string[]): LinePrefixStats {
-	const stats: LinePrefixStats = {
-		nonEmpty: 0,
-		headerCount: 0,
-		hashPrefixCount: 0,
-		diffPlusHashPrefixCount: 0,
-		diffPlusCount: 0,
-		truncationNoticeCount: 0,
-	};
-
-	for (const line of lines) {
-		if (line.length === 0) continue;
-		if (READ_TRUNCATION_NOTICE_RE.test(line)) {
-			stats.truncationNoticeCount++;
-			continue;
-		}
-		if (HL_HEADER_RE.test(line)) {
-			stats.nonEmpty++;
-			stats.headerCount++;
-			continue;
-		}
-		stats.nonEmpty++;
-		if (HL_PREFIX_RE.test(line)) stats.hashPrefixCount++;
-		if (HL_PREFIX_PLUS_RE.test(line)) stats.diffPlusHashPrefixCount++;
-		if (DIFF_PLUS_RE.test(line)) stats.diffPlusCount++;
-	}
-	return stats;
-}
-
-export function stripNewLinePrefixes(lines: string[]): string[] {
-	const stats = collectLinePrefixStats(lines);
-	if (stats.nonEmpty === 0) return lines;
-
-	const contentLineCount = stats.nonEmpty - stats.headerCount;
-	const stripHash = contentLineCount > 0 && stats.hashPrefixCount === contentLineCount;
-	const stripPlus =
-		!stripHash &&
-		stats.diffPlusHashPrefixCount === 0 &&
-		stats.diffPlusCount > 0 &&
-		stats.diffPlusCount >= stats.nonEmpty * 0.5;
-
-	if (!stripHash && !stripPlus && stats.diffPlusHashPrefixCount === 0) return lines;
-
-	return lines
-		.filter(line => !READ_TRUNCATION_NOTICE_RE.test(line) && !(stripHash && HL_HEADER_RE.test(line)))
-		.map(line => {
-			if (stripHash) return stripLeadingHashlinePrefixes(line);
-			if (stripPlus) return line.replace(DIFF_PLUS_RE, "");
-			if (stats.diffPlusHashPrefixCount > 0 && HL_PREFIX_PLUS_RE.test(line)) {
-				return line.replace(HL_PREFIX_RE, "");
-			}
-			return line;
-		});
-}
-
-export function stripHashlinePrefixes(lines: string[]): string[] {
-	const stats = collectLinePrefixStats(lines);
-	if (stats.nonEmpty === 0) return lines;
-	const contentLineCount = stats.nonEmpty - stats.headerCount;
-	if (contentLineCount === 0 || stats.hashPrefixCount !== contentLineCount) return lines;
-	return lines
-		.filter(line => !READ_TRUNCATION_NOTICE_RE.test(line) && !HL_HEADER_RE.test(line))
-		.map(line => stripLeadingHashlinePrefixes(line));
-}
-
-/**
- * Normalize line payloads by stripping read/search line prefixes. `null` /
- * `undefined` yield `[]`; a single multiline string is split on `\n`.
- */
-export function hashlineParseText(edit: string[] | string | null | undefined): string[] {
-	if (edit == null) return [];
-	if (typeof edit === "string") {
-		const trimmed = edit.endsWith("\n") ? edit.slice(0, -1) : edit;
-		edit = trimmed.replaceAll("\r", "").split("\n");
-	}
-	return stripNewLinePrefixes(edit);
-}

package/src/hashline/recovery.ts

@@ -1,139 +0,0 @@
-import * as Diff from "diff";
-import { generateDiffString } from "../edit/diff";
-import type { FileReadCache, FileReadSnapshot } from "../edit/file-read-cache";
-import { applyHashlineEdits, type HashlineApplyResult } from "./apply";
-import { computeFileHash } from "./hash";
-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[];
-}
-
-// Section hashes are line-precise; never let Diff.applyPatch slide a hunk onto a
-// duplicate closer 100+ lines away. If snapshot replay does not align exactly,
-// refuse and let the model re-read.
-const HASHLINE_RECOVERY_FUZZ_FACTOR = 0;
-
-const HASHLINE_RECOVERY_EXTERNAL_WARNING =
-	"Recovered from a stale file hash using a previous read snapshot (file changed externally between read and edit).";
-const HASHLINE_RECOVERY_SESSION_CHAIN_WARNING =
-	"Recovered from a stale file hash using an earlier in-session snapshot (the file hash advanced after a prior edit in this session).";
-const HASHLINE_RECOVERY_SESSION_REPLAY_WARNING =
-	"Recovered by replaying your edits onto the current file content — your previous edit in this session changed line(s) you re-targeted with a stale hash. Verify the diff matches your intent before continuing.";
-
-function applyEditsToSnapshot(
-	previousText: string,
-	currentText: string,
-	edits: HashlineEdit[],
-	options: HashlineApplyOptions,
-	recoveryWarning: string,
-): HashlineRecoveryResult | null {
-	let applied: HashlineApplyResult;
-	try {
-		applied = applyHashlineEdits(previousText, edits, options);
-	} catch {
-		return null;
-	}
-	if (applied.lines === previousText) return null;
-
-	const patch = Diff.structuredPatch("file", "file", previousText, applied.lines, "", "", { context: 3 });
-	const merged = Diff.applyPatch(currentText, patch, { fuzzFactor: HASHLINE_RECOVERY_FUZZ_FACTOR });
-	if (typeof merged !== "string" || merged === currentText) return null;
-
-	const mergedDiff = generateDiffString(currentText, merged);
-	const hasNetChange = mergedDiff.firstChangedLine !== undefined;
-	const recoveryWarnings = hasNetChange
-		? [recoveryWarning, ...(applied.warnings ?? [])]
-		: [...(applied.warnings ?? [])];
-
-	return {
-		lines: merged,
-		firstChangedLine: mergedDiff.firstChangedLine ?? applied.firstChangedLine,
-		warnings: recoveryWarnings,
-	};
-}
-
-function replaySessionChainOnCurrent(
-	previousText: string,
-	currentText: string,
-	edits: HashlineEdit[],
-	options: HashlineApplyOptions,
-): HashlineRecoveryResult | null {
-	// Only safe when no insert/delete shifted line counts in the prior edit
-	// chain: if total line counts match, every line number in `edits` still
-	// resolves to the same logical row.
-	if (previousText.split("\n").length !== currentText.split("\n").length) return null;
-	let applied: HashlineApplyResult;
-	try {
-		applied = applyHashlineEdits(currentText, edits, options);
-	} catch {
-		return null;
-	}
-	if (applied.lines === currentText) return null;
-	return {
-		lines: applied.lines,
-		firstChangedLine: applied.firstChangedLine,
-		warnings: [HASHLINE_RECOVERY_SESSION_REPLAY_WARNING, ...(applied.warnings ?? [])],
-	};
-}
-
-function buildSparseOverlayText(currentText: string, snapshotLines: ReadonlyMap<number, string>): string {
-	const overlaid = currentText.split("\n");
-	let maxCachedLine = 0;
-	for (const lineNum of snapshotLines.keys()) {
-		if (lineNum > maxCachedLine) maxCachedLine = lineNum;
-	}
-	while (overlaid.length < maxCachedLine) overlaid.push("");
-	for (const [lineNum, content] of snapshotLines) {
-		overlaid[lineNum - 1] = content;
-	}
-	return overlaid.join("\n");
-}
-
-function isHeadSnapshot(head: FileReadSnapshot | null, snapshot: FileReadSnapshot): boolean {
-	return head === snapshot;
-}
-
-function resolveRecoveryWarning(head: FileReadSnapshot | null, snapshot: FileReadSnapshot): string {
-	return isHeadSnapshot(head, snapshot) ? HASHLINE_RECOVERY_EXTERNAL_WARNING : HASHLINE_RECOVERY_SESSION_CHAIN_WARNING;
-}
-
-/**
- * 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 function tryRecoverHashlineWithCache(args: HashlineRecoveryArgs): HashlineRecoveryResult | null {
-	const { cache, absolutePath, currentText, fileHash, edits, options } = args;
-	const head = cache.get(absolutePath);
-	const snapshot = cache.getByHash(absolutePath, fileHash);
-	if (!snapshot || snapshot.lines.size === 0) return null;
-
-	const recoveryWarning = resolveRecoveryWarning(head, snapshot);
-	const isSessionChain = !isHeadSnapshot(head, snapshot);
-	if (snapshot.fullText !== undefined) {
-		const merged = applyEditsToSnapshot(snapshot.fullText, currentText, edits, options, recoveryWarning);
-		if (merged !== null) return merged;
-		// Session-chain fast-path: prior in-session edit changed the same line(s)
-		// the model is now re-targeting with the stale hash. When line counts
-		// match, the edits' line numbers still resolve to the right rows — replay
-		// onto the current text directly.
-		if (isSessionChain) return replaySessionChainOnCurrent(snapshot.fullText, currentText, edits, options);
-		return null;
-	}
-
-	const overlayText = buildSparseOverlayText(currentText, snapshot.lines);
-	if (computeFileHash(overlayText) !== fileHash) return null;
-	return applyEditsToSnapshot(overlayText, currentText, edits, options, recoveryWarning);
-}

package/src/hashline/stream.ts

@@ -1,123 +0,0 @@
-import { formatNumberedLine } from "./hash";
-import type { HashlineStreamOptions } from "./types";
-
-interface ResolvedHashlineStreamOptions {
-	startLine: number;
-	maxChunkLines: number;
-	maxChunkBytes: number;
-}
-
-function resolveHashlineStreamOptions(options: HashlineStreamOptions): ResolvedHashlineStreamOptions {
-	return {
-		startLine: options.startLine ?? 1,
-		maxChunkLines: options.maxChunkLines ?? 200,
-		maxChunkBytes: options.maxChunkBytes ?? 64 * 1024,
-	};
-}
-
-interface HashlineChunkEmitter {
-	pushLine: (line: string) => string[];
-	flush: () => string | undefined;
-}
-
-function createHashlineChunkEmitter(options: ResolvedHashlineStreamOptions): HashlineChunkEmitter {
-	let lineNumber = options.startLine;
-	let outLines: string[] = [];
-	let outBytes = 0;
-
-	const flush = (): string | undefined => {
-		if (outLines.length === 0) return undefined;
-		const chunk = outLines.join("\n");
-		outLines = [];
-		outBytes = 0;
-		return chunk;
-	};
-
-	const pushLine = (line: string): string[] => {
-		const formatted = formatNumberedLine(lineNumber, line);
-		lineNumber++;
-
-		const chunks: string[] = [];
-		const sepBytes = outLines.length === 0 ? 0 : 1;
-		const lineBytes = Buffer.byteLength(formatted, "utf-8");
-		const wouldOverflow =
-			outLines.length >= options.maxChunkLines || outBytes + sepBytes + lineBytes > options.maxChunkBytes;
-
-		if (outLines.length > 0 && wouldOverflow) {
-			const flushed = flush();
-			if (flushed) chunks.push(flushed);
-		}
-
-		outLines.push(formatted);
-		outBytes += (outLines.length === 1 ? 0 : 1) + lineBytes;
-
-		if (outLines.length >= options.maxChunkLines || outBytes >= options.maxChunkBytes) {
-			const flushed = flush();
-			if (flushed) chunks.push(flushed);
-		}
-		return chunks;
-	};
-
-	return { pushLine, flush };
-}
-
-function isReadableStream(value: unknown): value is ReadableStream<Uint8Array> {
-	return (
-		typeof value === "object" &&
-		value !== null &&
-		"getReader" in value &&
-		typeof (value as { getReader?: unknown }).getReader === "function"
-	);
-}
-
-async function* bytesFromReadableStream(stream: ReadableStream<Uint8Array>): AsyncGenerator<Uint8Array> {
-	const reader = stream.getReader();
-	try {
-		while (true) {
-			const { done, value } = await reader.read();
-			if (done) return;
-			if (value) yield value;
-		}
-	} finally {
-		reader.releaseLock();
-	}
-}
-
-export async function* streamHashLinesFromUtf8(
-	source: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>,
-	options: HashlineStreamOptions = {},
-): AsyncGenerator<string> {
-	const resolved = resolveHashlineStreamOptions(options);
-	const decoder = new TextDecoder("utf-8");
-	const chunks = isReadableStream(source) ? bytesFromReadableStream(source) : source;
-	const emitter = createHashlineChunkEmitter(resolved);
-
-	let pending = "";
-	let sawAnyLine = false;
-
-	for await (const chunk of chunks) {
-		pending += decoder.decode(chunk, { stream: true });
-		let nl = pending.indexOf("\n");
-		while (nl !== -1) {
-			const raw = pending.slice(0, nl);
-			const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
-			sawAnyLine = true;
-			for (const out of emitter.pushLine(line)) yield out;
-			pending = pending.slice(nl + 1);
-			nl = pending.indexOf("\n");
-		}
-	}
-
-	pending += decoder.decode();
-	if (pending.length > 0) {
-		sawAnyLine = true;
-		const tail = pending.endsWith("\r") ? pending.slice(0, -1) : pending;
-		for (const out of emitter.pushLine(tail)) yield out;
-	}
-	if (!sawAnyLine) {
-		for (const out of emitter.pushLine("")) yield out;
-	}
-
-	const last = emitter.flush();
-	if (last) yield last;
-}