@oh-my-pi/pi-coding-agent 14.8.0 → 14.9.0

package/src/hashline/input.ts

@@ -0,0 +1,110 @@
+import * as path from "node:path";
+import { FILE_HEADER_PREFIX } from "./constants";
+import { HL_EDIT_SEP } from "./hash";
+import type { SplitHashlineOptions } from "./types";
+import { stripTrailingCarriageReturn } from "./utils";
+
+export interface HashlineInputSection {
+	path: string;
+	diff: string;
+}
+
+function unquoteHashlinePath(pathText: string): string {
+	if (pathText.length < 2) return pathText;
+	const first = pathText[0];
+	const last = pathText[pathText.length - 1];
+	if ((first === '"' || first === "'") && first === last) return pathText.slice(1, -1);
+	return pathText;
+}
+
+function normalizeHashlinePath(rawPath: string, cwd?: string): string {
+	const unquoted = unquoteHashlinePath(rawPath.trim());
+	if (!cwd || !path.isAbsolute(unquoted)) return unquoted;
+	const relative = path.relative(path.resolve(cwd), path.resolve(unquoted));
+	const isWithinCwd = relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+	return isWithinCwd ? relative || "." : unquoted;
+}
+
+function parseHashlineHeaderLine(line: string, cwd?: string): HashlineInputSection | null {
+	const trimmed = line.trimEnd();
+	if (trimmed === FILE_HEADER_PREFIX) {
+		throw new Error(`Input header "${FILE_HEADER_PREFIX}" is empty; provide a file path.`);
+	}
+	if (!trimmed.startsWith(FILE_HEADER_PREFIX)) return null;
+	const parsedPath = normalizeHashlinePath(trimmed.slice(1), cwd);
+	if (parsedPath.length === 0) {
+		throw new Error(`Input header "${FILE_HEADER_PREFIX}" is empty; provide a file path.`);
+	}
+	return { path: parsedPath, diff: "" };
+}
+
+function stripLeadingBlankLines(input: string): string {
+	const stripped = input.startsWith("\uFEFF") ? input.slice(1) : input;
+	const lines = stripped.split("\n");
+	while (lines.length > 0 && lines[0].replace(/\r$/, "").trim().length === 0) lines.shift();
+	return lines.join("\n");
+}
+
+export function containsRecognizableHashlineOperations(input: string): boolean {
+	for (const rawLine of input.split("\n")) {
+		const line = stripTrailingCarriageReturn(rawLine);
+		if (/^[+<=-]\s+/.test(line) || line.startsWith(HL_EDIT_SEP)) return true;
+	}
+	return false;
+}
+
+function normalizeFallbackInput(input: string, options: SplitHashlineOptions): string {
+	const stripped = input.startsWith("\uFEFF") ? input.slice(1) : input;
+	const hasExplicitHeader = stripped
+		.split("\n")
+		.some(rawLine => parseHashlineHeaderLine(stripTrailingCarriageReturn(rawLine), options.cwd) !== null);
+	if (hasExplicitHeader) return input;
+
+	if (!options.path || !containsRecognizableHashlineOperations(input)) return input;
+	const fallbackPath = normalizeHashlinePath(options.path, options.cwd);
+	if (fallbackPath.length === 0) return input;
+	return `${FILE_HEADER_PREFIX} ${fallbackPath}\n${input}`;
+}
+
+export function splitHashlineInput(input: string, options: SplitHashlineOptions = {}): { path: string; diff: string } {
+	const [section] = splitHashlineInputs(input, options);
+	return section;
+}
+
+export function splitHashlineInputs(input: string, options: SplitHashlineOptions = {}): HashlineInputSection[] {
+	const stripped = stripLeadingBlankLines(normalizeFallbackInput(input, options));
+	const lines = stripped.split("\n");
+	const firstLine = stripTrailingCarriageReturn(lines[0] ?? "");
+
+	if (parseHashlineHeaderLine(firstLine, options.cwd) === null) {
+		const preview = JSON.stringify(firstLine.slice(0, 120));
+		throw new Error(
+			`input must begin with "@PATH" on the first non-blank line; got: ${preview}. ` +
+				`Example: "@src/foo.ts" then edit ops.`,
+		);
+	}
+
+	const sections: HashlineInputSection[] = [];
+	let currentPath = "";
+	let currentLines: string[] = [];
+
+	const flush = () => {
+		if (currentPath.length === 0) return;
+		sections.push({ path: currentPath, diff: currentLines.join("\n") });
+		currentLines = [];
+	};
+
+	for (const rawLine of lines) {
+		const line = stripTrailingCarriageReturn(rawLine);
+		const header = parseHashlineHeaderLine(line, options.cwd);
+		if (header !== null) {
+			flush();
+			currentPath = header.path;
+			currentLines = [];
+		} else {
+			currentLines.push(rawLine);
+		}
+	}
+	flush();
+	return sections;
+}

package/src/hashline/parser.ts

@@ -0,0 +1,220 @@
+import { RANGE_INTERIOR_HASH } from "./constants";
+import { describeAnchorExamples, HL_EDIT_SEP, HL_EDIT_SEP_RE_RAW, HL_HASH_CAPTURE_RE_RAW } from "./hash";
+import type { Anchor, HashlineCursor, HashlineEdit } from "./types";
+import { stripTrailingCarriageReturn } from "./utils";
+
+const HL_EDIT_SEPARATOR_RE = HL_EDIT_SEP_RE_RAW;
+const LID_CAPTURE_RE = new RegExp(`^${HL_HASH_CAPTURE_RE_RAW}$`);
+
+function parseLid(raw: string, lineNum: number): Anchor {
+	const match = LID_CAPTURE_RE.exec(raw);
+	if (!match) {
+		throw new Error(
+			`line ${lineNum}: expected a full anchor such as ${describeAnchorExamples("119")}; ` +
+				`got ${JSON.stringify(raw)}.`,
+		);
+	}
+	return { line: Number.parseInt(match[1], 10), hash: match[2] };
+}
+
+interface ParsedRange {
+	start: Anchor;
+	end: Anchor;
+}
+
+function parseRange(raw: string, lineNum: number): ParsedRange {
+	if (!raw.includes("..")) {
+		throw new Error(
+			`line ${lineNum}: explicit ranges are required for delete/replace. ` +
+				`Repeat the same anchor on both sides for a one-line edit (for example, ` +
+				`${describeAnchorExamples("119")}..${describeAnchorExamples("119")}); ` +
+				`got ${JSON.stringify(raw)}.`,
+		);
+	}
+	const [startRaw, endRaw, extra] = raw.split("..");
+	if (extra !== undefined || !startRaw || !endRaw) {
+		throw new Error(
+			`line ${lineNum}: range must include exactly two full anchors separated by "..". ` +
+				`For a one-line edit, repeat the same anchor on both sides.`,
+		);
+	}
+	const start = parseLid(startRaw, lineNum);
+	const end = parseLid(endRaw, lineNum);
+	if (end.line < start.line) {
+		throw new Error(`line ${lineNum}: range ${startRaw}..${endRaw} ends before it starts.`);
+	}
+	if (end.line === start.line && end.hash !== start.hash) {
+		throw new Error(`line ${lineNum}: range ${startRaw}..${endRaw} uses two different hashes for the same line.`);
+	}
+	return { start, end };
+}
+
+function expandRange(range: ParsedRange): Anchor[] {
+	const anchors: Anchor[] = [];
+	for (let line = range.start.line; line <= range.end.line; line++) {
+		const hash =
+			line === range.start.line ? range.start.hash : line === range.end.line ? range.end.hash : RANGE_INTERIOR_HASH;
+		anchors.push({ line, hash });
+	}
+	return anchors;
+}
+
+function parseInsertTarget(raw: string, lineNum: number, kind: "before" | "after"): HashlineCursor {
+	if (raw === "BOF") return { kind: "bof" };
+	if (raw === "EOF") return { kind: "eof" };
+	const cursorKind = kind === "before" ? "before_anchor" : "after_anchor";
+	return { kind: cursorKind, anchor: parseLid(raw, lineNum) };
+}
+
+const INSERT_BEFORE_OP_RE = /^<\s*(\S+)$/;
+const INSERT_AFTER_OP_RE = /^\+\s*(\S+)$/;
+const DELETE_OP_RE = /^-\s*(\S+)$/;
+const REPLACE_OP_RE = /^=\s*(\S+)$/;
+const INLINE_BEFORE_OP_RE = new RegExp(`^<\\s*${HL_HASH_CAPTURE_RE_RAW}${HL_EDIT_SEPARATOR_RE}(.*)$`);
+const INLINE_AFTER_OP_RE = new RegExp(`^\\+\\s*${HL_HASH_CAPTURE_RE_RAW}${HL_EDIT_SEPARATOR_RE}(.*)$`);
+
+export function cloneCursor(cursor: HashlineCursor): HashlineCursor {
+	if (cursor.kind === "before_anchor") return { kind: "before_anchor", anchor: { ...cursor.anchor } };
+	if (cursor.kind === "after_anchor") return { kind: "after_anchor", anchor: { ...cursor.anchor } };
+	return cursor;
+}
+
+function collectPayload(
+	lines: string[],
+	startIndex: number,
+	opLineNum: number,
+	requirePayload: boolean,
+): { payload: string[]; nextIndex: number } {
+	const payload: string[] = [];
+	let index = startIndex;
+	while (index < lines.length) {
+		const line = stripTrailingCarriageReturn(lines[index]);
+		if (!line.startsWith(HL_EDIT_SEP)) break;
+		payload.push(line.slice(1));
+		index++;
+	}
+	if (payload.length === 0 && requirePayload) {
+		throw new Error(`line ${opLineNum}: + and < operations require at least one ${HL_EDIT_SEP}TEXT payload line.`);
+	}
+	return { payload, nextIndex: index };
+}
+
+export function parseHashline(diff: string): HashlineEdit[] {
+	return parseHashlineWithWarnings(diff).edits;
+}
+
+export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]; warnings: string[] } {
+	const edits: HashlineEdit[] = [];
+	const warnings: string[] = [];
+	const lines = diff.split("\n");
+	let editIndex = 0;
+
+	const pushInsert = (cursor: HashlineCursor, text: string, lineNum: number) => {
+		edits.push({ kind: "insert", cursor: cloneCursor(cursor), text, lineNum, index: editIndex++ });
+	};
+
+	for (let i = 0; i < lines.length; ) {
+		const lineNum = i + 1;
+		const line = stripTrailingCarriageReturn(lines[i]);
+
+		if (line.trim().length === 0) {
+			i++;
+			continue;
+		}
+		if (line.startsWith(HL_EDIT_SEP)) {
+			throw new Error(`line ${lineNum}: payload line has no preceding +, <, or = operation.`);
+		}
+
+		const inlineBeforeMatch = INLINE_BEFORE_OP_RE.exec(line);
+		if (inlineBeforeMatch) {
+			const anchor = parseLid(`${inlineBeforeMatch[1]}${inlineBeforeMatch[2]}`, lineNum);
+			edits.push({
+				kind: "modify",
+				anchor,
+				prefix: inlineBeforeMatch[3],
+				suffix: "",
+				lineNum,
+				index: editIndex++,
+			});
+			const cursor: HashlineCursor = { kind: "before_anchor", anchor };
+			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, false);
+			for (const text of payload) pushInsert(cursor, text, lineNum);
+			i = nextIndex;
+			continue;
+		}
+
+		const inlineAfterMatch = INLINE_AFTER_OP_RE.exec(line);
+		if (inlineAfterMatch) {
+			const anchor = parseLid(`${inlineAfterMatch[1]}${inlineAfterMatch[2]}`, lineNum);
+			edits.push({
+				kind: "modify",
+				anchor,
+				prefix: "",
+				suffix: inlineAfterMatch[3],
+				lineNum,
+				index: editIndex++,
+			});
+			const cursor: HashlineCursor = { kind: "after_anchor", anchor };
+			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, false);
+			for (const text of payload) pushInsert(cursor, text, lineNum);
+			i = nextIndex;
+			continue;
+		}
+
+		const insertBeforeMatch = INSERT_BEFORE_OP_RE.exec(line);
+		if (insertBeforeMatch) {
+			const cursor = parseInsertTarget(insertBeforeMatch[1], lineNum, "before");
+			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, true);
+			for (const text of payload) pushInsert(cursor, text, lineNum);
+			i = nextIndex;
+			continue;
+		}
+
+		const insertAfterMatch = INSERT_AFTER_OP_RE.exec(line);
+		if (insertAfterMatch) {
+			const cursor = parseInsertTarget(insertAfterMatch[1], lineNum, "after");
+			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, true);
+			for (const text of payload) pushInsert(cursor, text, lineNum);
+			i = nextIndex;
+			continue;
+		}
+
+		const deleteMatch = DELETE_OP_RE.exec(line);
+		if (deleteMatch) {
+			for (const anchor of expandRange(parseRange(deleteMatch[1], lineNum))) {
+				edits.push({ kind: "delete", anchor, lineNum, index: editIndex++ });
+			}
+			i++;
+			continue;
+		}
+
+		const replaceMatch = REPLACE_OP_RE.exec(line);
+		if (replaceMatch) {
+			const range = parseRange(replaceMatch[1], lineNum);
+			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, false);
+			// `= A..B` with no payload blanks the range to a single empty line.
+			const replacement = payload.length === 0 ? [""] : payload;
+			for (const text of replacement) {
+				edits.push({
+					kind: "insert",
+					cursor: { kind: "before_anchor", anchor: { ...range.start } },
+					text,
+					lineNum,
+					index: editIndex++,
+				});
+			}
+			for (const anchor of expandRange(range)) {
+				edits.push({ kind: "delete", anchor, lineNum, index: editIndex++ });
+			}
+			i = nextIndex;
+			continue;
+		}
+
+		throw new Error(
+			`line ${lineNum}: unrecognized op. Use < ANCHOR (insert before), + ANCHOR (insert after), - A..B (delete), = A..B (replace), or "${HL_EDIT_SEP}TEXT" payload lines. ` +
+				`Got ${JSON.stringify(line)}.`,
+		);
+	}
+
+	return { edits, warnings };
+}

package/src/hashline/prefixes.ts

@@ -0,0 +1,101 @@
+import { HL_BODY_SEP_RE_RAW } from "./hash";
+
+const HL_OUTPUT_PREFIX_SEPARATOR_RE = `[:${HL_BODY_SEP_RE_RAW}]`;
+const HL_PREFIX_RE = new RegExp(`^\\s*(?:>>>|>>)?\\s*(?:[+*]\\s*)?\\d+[a-z]{2}${HL_OUTPUT_PREFIX_SEPARATOR_RE}`);
+const HL_PREFIX_PLUS_RE = new RegExp(`^\\s*(?:>>>|>>)?\\s*\\+\\s*\\d+[a-z]{2}${HL_OUTPUT_PREFIX_SEPARATOR_RE}`);
+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 tag (`123ab|`) or, for diff-style
+// echoes, a leading `+`. These helpers detect that and recover the raw text.
+// ───────────────────────────────────────────────────────────────────────────
+
+type LinePrefixStats = {
+	nonEmpty: number;
+	hashPrefixCount: number;
+	diffPlusHashPrefixCount: number;
+	diffPlusCount: number;
+	truncationNoticeCount: number;
+};
+
+function collectLinePrefixStats(lines: string[]): LinePrefixStats {
+	const stats: LinePrefixStats = {
+		nonEmpty: 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;
+		}
+		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 stripHash = stats.hashPrefixCount > 0 && stats.hashPrefixCount === stats.nonEmpty;
+	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))
+		.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;
+	if (stats.hashPrefixCount !== stats.nonEmpty) return lines;
+	return lines.filter(line => !READ_TRUNCATION_NOTICE_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

@@ -0,0 +1,72 @@
+import * as Diff from "diff";
+import { generateDiffString } from "../edit/diff";
+import type { FileReadCache } from "../edit/file-read-cache";
+import { HashlineMismatchError } from "./anchors";
+import { applyHashlineEdits, type HashlineApplyResult } from "./apply";
+import type { HashlineApplyOptions, HashlineEdit } from "./types";
+
+export interface HashlineRecoveryArgs {
+	cache: FileReadCache;
+	absolutePath: string;
+	currentText: string;
+	edits: HashlineEdit[];
+	options: HashlineApplyOptions;
+}
+
+export interface HashlineRecoveryResult {
+	lines: string;
+	firstChangedLine: number | undefined;
+	warnings: string[];
+}
+
+const HASHLINE_RECOVERY_FUZZ_FACTOR = 3;
+
+const HASHLINE_RECOVERY_WARNING =
+	"Recovered from stale anchors using a previous read snapshot (file changed externally between read and edit).";
+
+/**
+ * Attempt to recover from a `HashlineMismatchError` 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 — callers should propagate the original mismatch error in that
+ * case.
+ */
+export function tryRecoverHashlineWithCache(args: HashlineRecoveryArgs): HashlineRecoveryResult | null {
+	const { cache, absolutePath, currentText, edits, options } = args;
+	const snapshot = cache.get(absolutePath);
+	if (!snapshot || snapshot.lines.size === 0) return null;
+
+	const overlaid = currentText.split("\n");
+	let maxCachedLine = 0;
+	for (const lineNum of snapshot.lines.keys()) {
+		if (lineNum > maxCachedLine) maxCachedLine = lineNum;
+	}
+	while (overlaid.length < maxCachedLine) overlaid.push("");
+	for (const [lineNum, content] of snapshot.lines) {
+		overlaid[lineNum - 1] = content;
+	}
+	const previousText = overlaid.join("\n");
+	if (previousText === currentText) return null;
+
+	let applied: HashlineApplyResult;
+	try {
+		applied = applyHashlineEdits(previousText, edits, options);
+	} catch (err) {
+		if (err instanceof HashlineMismatchError) return null;
+		throw err;
+	}
+	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 recoveryWarnings = [HASHLINE_RECOVERY_WARNING, ...(applied.warnings ?? [])];
+
+	return {
+		lines: merged,
+		firstChangedLine: mergedDiff.firstChangedLine ?? applied.firstChangedLine,
+		warnings: recoveryWarnings,
+	};
+}

package/src/hashline/stream.ts

@@ -0,0 +1,123 @@
+import { formatHashLine } 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 = formatHashLine(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;
+}

package/src/hashline/types.ts

@@ -0,0 +1,69 @@
+import type { Static } from "@sinclair/typebox";
+import { Type } from "@sinclair/typebox";
+import type { LspBatchRequest } from "../edit/renderer";
+import type { WritethroughCallback, WritethroughDeferredHandle } from "../lsp";
+import type { ToolSession } from "../tools";
+
+export interface HashMismatch {
+	line: number;
+	expected: string;
+	actual: string;
+}
+
+export type Anchor = {
+	line: number;
+	hash: string;
+	contentHint?: string;
+};
+
+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 }
+	| { kind: "modify"; anchor: Anchor; prefix: string; suffix: string; lineNum: number; index: number };
+
+export const hashlineEditParamsSchema = Type.Object({ input: Type.String() });
+export type HashlineParams = Static<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/hashline/utils.ts

@@ -0,0 +1,3 @@
+export function stripTrailingCarriageReturn(line: string): string {
+	return line.endsWith("\r") ? line.slice(0, -1) : line;
+}