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

package/src/hashline/diff.ts

@@ -0,0 +1,56 @@
+import { generateDiffString } from "../edit/diff";
+import { normalizeToLF, stripBom } from "../edit/normalize";
+import { readEditFileText } from "../edit/read-file";
+import { resolveToCwd } from "../tools/path-utils";
+import { applyHashlineEdits } from "./apply";
+import { type HashlineInputSection, splitHashlineInputs } from "./input";
+import { parseHashline } from "./parser";
+import type { HashlineApplyOptions } from "./types";
+
+async function readHashlineFileText(
+	_file: { text(): Promise<string> },
+	absolutePath: string,
+	pathText: string,
+): Promise<string> {
+	try {
+		return await readEditFileText(absolutePath, pathText);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(message || `Unable to read ${pathText}`);
+	}
+}
+
+export async function computeHashlineSectionDiff(
+	section: HashlineInputSection,
+	cwd: string,
+	options: HashlineApplyOptions = {},
+): Promise<{ diff: string; firstChangedLine: number | undefined } | { error: string }> {
+	try {
+		const absolutePath = resolveToCwd(section.path, cwd);
+		const rawContent = await readHashlineFileText(Bun.file(absolutePath), absolutePath, section.path);
+		const { text: content } = stripBom(rawContent);
+		const normalized = normalizeToLF(content);
+		const result = applyHashlineEdits(normalized, parseHashline(section.diff), options);
+		if (normalized === result.lines) return { error: `No changes would be made to ${section.path}.` };
+		return generateDiffString(normalized, result.lines);
+	} catch (err) {
+		return { error: err instanceof Error ? err.message : String(err) };
+	}
+}
+
+export async function computeHashlineDiff(
+	input: { input: string; path?: string },
+	cwd: string,
+	options: HashlineApplyOptions = {},
+): Promise<{ diff: string; firstChangedLine: number | undefined } | { error: string }> {
+	let sections: HashlineInputSection[];
+	try {
+		sections = splitHashlineInputs(input.input, { cwd, path: input.path });
+	} catch (err) {
+		return { error: err instanceof Error ? err.message : String(err) };
+	}
+	if (sections.length !== 1) {
+		return { error: "Streaming diff preview supports exactly one hashline section." };
+	}
+	return computeHashlineSectionDiff(sections[0], cwd, options);
+}

package/src/hashline/execute.ts

@@ -0,0 +1,268 @@
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import { isEnoent } from "@oh-my-pi/pi-utils";
+import { generateDiffString } from "../edit/diff";
+import { getFileReadCache } from "../edit/file-read-cache";
+import { detectLineEnding, normalizeToLF, restoreLineEndings, stripBom } from "../edit/normalize";
+import { readEditFileText, serializeEditFileText } from "../edit/read-file";
+import type { EditToolDetails } from "../edit/renderer";
+import type { ToolSession } from "../tools";
+import { assertEditableFileContent } from "../tools/auto-generated-guard";
+import { invalidateFsScanAfterWrite } from "../tools/fs-cache-invalidation";
+import { outputMeta } from "../tools/output-meta";
+import { enforcePlanModeWrite, resolvePlanPath } from "../tools/plan-mode-guard";
+import { HashlineMismatchError } from "./anchors";
+import { applyHashlineEdits, type HashlineApplyResult } from "./apply";
+import { buildCompactHashlineDiffPreview } from "./diff-preview";
+import { type HashlineInputSection, splitHashlineInputs } from "./input";
+import { parseHashlineWithWarnings } from "./parser";
+import { tryRecoverHashlineWithCache } from "./recovery";
+import type {
+	ExecuteHashlineSingleOptions,
+	HashlineApplyOptions,
+	HashlineEdit,
+	hashlineEditParamsSchema,
+} from "./types";
+
+interface ReadHashlineFileResult {
+	exists: boolean;
+	rawContent: string;
+}
+
+async function readHashlineFile(absolutePath: string, pathText: string): Promise<ReadHashlineFileResult> {
+	try {
+		return { exists: true, rawContent: await readEditFileText(absolutePath, pathText) };
+	} catch (error) {
+		if (isEnoent(error)) return { exists: false, rawContent: "" };
+		if (error instanceof Error && error.message === `File not found: ${pathText}`)
+			return { exists: false, rawContent: "" };
+		throw error;
+	}
+}
+
+function hasAnchorScopedEdit(edits: HashlineEdit[]): boolean {
+	return edits.some(edit => {
+		if (edit.kind === "delete") return true;
+		if (edit.kind === "modify") return true;
+		return edit.cursor.kind === "before_anchor" || edit.cursor.kind === "after_anchor";
+	});
+}
+
+function formatNoChangeDiagnostic(pathText: string): string {
+	return `Edits to ${pathText} resulted in no changes being made.`;
+}
+
+function getHashlineApplyOptions(session: ToolSession): HashlineApplyOptions {
+	return {
+		autoDropPureInsertDuplicates: session.settings.get("edit.hashlineAutoDropPureInsertDuplicates"),
+	};
+}
+
+function getTextContent(result: AgentToolResult<EditToolDetails>): string {
+	return result.content.map(part => (part.type === "text" ? part.text : "")).join("\n");
+}
+
+function getEditDetails(result: AgentToolResult<EditToolDetails>): EditToolDetails {
+	return result.details ?? { diff: "" };
+}
+
+/**
+ * Apply hashline edits with anchor-stale recovery: on `HashlineMismatchError`,
+ * consult the read-snapshot cache for the file and 3-way-merge the edits onto
+ * the current text. If recovery succeeds, return the merged result with a
+ * synthetic warning. Otherwise re-throw the original mismatch error.
+ */
+function applyHashlineEditsWithRecovery(
+	session: ToolSession,
+	absolutePath: string,
+	text: string,
+	edits: HashlineEdit[],
+	options: HashlineApplyOptions,
+): HashlineApplyResult {
+	try {
+		return applyHashlineEdits(text, edits, options);
+	} catch (err) {
+		if (!(err instanceof HashlineMismatchError)) throw err;
+		const recovered = tryRecoverHashlineWithCache({
+			cache: getFileReadCache(session),
+			absolutePath,
+			currentText: text,
+			edits,
+			options,
+		});
+		if (!recovered) throw err;
+		return {
+			lines: recovered.lines,
+			firstChangedLine: recovered.firstChangedLine,
+			warnings: recovered.warnings,
+		};
+	}
+}
+
+/**
+ * Run all the front-end checks (notebook guard, parse, plan-mode check, file
+ * load, edit application) without writing. Used to fail fast before applying
+ * any changes in a multi-section batch.
+ */
+async function preflightHashlineSection(options: ExecuteHashlineSingleOptions & HashlineInputSection): Promise<void> {
+	const { session, path: sectionPath, diff } = options;
+
+	const absolutePath = resolvePlanPath(session, sectionPath);
+	const { edits } = parseHashlineWithWarnings(diff);
+	enforcePlanModeWrite(session, sectionPath, { op: "update" });
+
+	const source = await readHashlineFile(absolutePath, sectionPath);
+	if (!source.exists && hasAnchorScopedEdit(edits)) throw new Error(`File not found: ${sectionPath}`);
+	if (source.exists) assertEditableFileContent(source.rawContent, sectionPath);
+
+	const { text } = stripBom(source.rawContent);
+	const normalized = normalizeToLF(text);
+	const result = applyHashlineEditsWithRecovery(
+		session,
+		absolutePath,
+		normalized,
+		edits,
+		getHashlineApplyOptions(session),
+	);
+	if (normalized === result.lines) throw new Error(formatNoChangeDiagnostic(sectionPath));
+}
+
+async function executeHashlineSection(
+	options: ExecuteHashlineSingleOptions & HashlineInputSection,
+): Promise<AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema>> {
+	const {
+		session,
+		path: sourcePath,
+		diff,
+		signal,
+		batchRequest,
+		writethrough,
+		beginDeferredDiagnosticsForPath,
+	} = options;
+
+	const absolutePath = resolvePlanPath(session, sourcePath);
+	const { edits, warnings: parseWarnings } = parseHashlineWithWarnings(diff);
+	enforcePlanModeWrite(session, sourcePath, { op: "update" });
+
+	const source = await readHashlineFile(absolutePath, sourcePath);
+	if (!source.exists && hasAnchorScopedEdit(edits)) throw new Error(`File not found: ${sourcePath}`);
+	if (source.exists) assertEditableFileContent(source.rawContent, sourcePath);
+
+	const { bom, text } = stripBom(source.rawContent);
+	const originalEnding = detectLineEnding(text);
+	const originalNormalized = normalizeToLF(text);
+	const result = applyHashlineEditsWithRecovery(
+		session,
+		absolutePath,
+		originalNormalized,
+		edits,
+		getHashlineApplyOptions(session),
+	);
+
+	if (originalNormalized === result.lines) {
+		return {
+			content: [{ type: "text", text: formatNoChangeDiagnostic(sourcePath) }],
+			details: { diff: "", op: "update", meta: outputMeta().get() },
+		};
+	}
+
+	const finalContent = await serializeEditFileText(
+		absolutePath,
+		sourcePath,
+		bom + restoreLineEndings(result.lines, originalEnding),
+	);
+	const diagnostics = await writethrough(
+		absolutePath,
+		finalContent,
+		signal,
+		Bun.file(absolutePath),
+		batchRequest,
+		dst => (dst === absolutePath ? beginDeferredDiagnosticsForPath(absolutePath) : undefined),
+	);
+	invalidateFsScanAfterWrite(absolutePath);
+	// The post-edit content is the freshest, most authoritative "model view"
+	// of the file: the model just received it back as the diff/preview. Cache
+	// it so a follow-up edit anchored against this state can still recover
+	// if the file is touched out-of-band before the next edit lands.
+	getFileReadCache(session).recordContiguous(absolutePath, 1, result.lines.split("\n"));
+
+	const diffResult = generateDiffString(originalNormalized, result.lines);
+	const meta = outputMeta()
+		.diagnostics(diagnostics?.summary ?? "", diagnostics?.messages ?? [])
+		.get();
+	const preview = buildCompactHashlineDiffPreview(diffResult.diff);
+
+	const warnings = [...parseWarnings, ...(result.warnings ?? [])];
+	const warningsBlock = warnings.length > 0 ? `\n\nWarnings:\n${warnings.join("\n")}` : "";
+	const previewBlock = preview.preview ? `\n${preview.preview}` : "";
+	const headline = preview.preview
+		? `${sourcePath}:`
+		: source.exists
+			? `Updated ${sourcePath}`
+			: `Created ${sourcePath}`;
+
+	return {
+		content: [{ type: "text", text: `${headline}${previewBlock}${warningsBlock}` }],
+		details: {
+			diff: diffResult.diff,
+			firstChangedLine: result.firstChangedLine ?? diffResult.firstChangedLine,
+			diagnostics,
+			op: source.exists ? "update" : "create",
+			meta,
+		},
+	};
+}
+
+export async function executeHashlineSingle(
+	options: ExecuteHashlineSingleOptions,
+): Promise<AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema>> {
+	const sections = mergeSamePathSections(
+		splitHashlineInputs(options.input, { cwd: options.session.cwd, path: options.path }),
+	);
+
+	// Fast path: a single section needs no preflight pass.
+	if (sections.length === 1) return executeHashlineSection({ ...options, ...sections[0] });
+
+	// Multi-section: validate everything up front so we don't apply a partial batch.
+	for (const section of sections) await preflightHashlineSection({ ...options, ...section });
+
+	const results = [];
+	for (const section of sections) {
+		results.push({ path: section.path, result: await executeHashlineSection({ ...options, ...section }) });
+	}
+
+	return {
+		content: [{ type: "text", text: results.map(({ result }) => getTextContent(result)).join("\n\n") }],
+		details: {
+			diff: results.map(({ result }) => getEditDetails(result).diff).join("\n"),
+			perFileResults: results.map(({ path: resultPath, result }) => {
+				const details = getEditDetails(result);
+				return {
+					path: resultPath,
+					diff: details.diff,
+					firstChangedLine: details.firstChangedLine,
+					diagnostics: details.diagnostics,
+					op: details.op,
+					move: details.move,
+					meta: details.meta,
+				};
+			}),
+		},
+	};
+}
+
+/**
+ * Collapse consecutive or interleaved sections targeting the same path into a
+ * single section with concatenated diffs. Anchors authored against the same
+ * file snapshot must be applied as one batch; otherwise the first sub-edit
+ * shifts line numbers out from under the second's anchors and validation fails.
+ * Path order is preserved by first occurrence.
+ */
+function mergeSamePathSections(sections: HashlineInputSection[]): HashlineInputSection[] {
+	const byPath = new Map<string, string[]>();
+	for (const section of sections) {
+		const existing = byPath.get(section.path);
+		if (existing) existing.push(section.diff);
+		else byPath.set(section.path, [section.diff]);
+	}
+	return Array.from(byPath, ([path, diffs]) => ({ path, diff: diffs.join("\n") }));
+}

package/src/{edit/modes/hashline.lark → hashline/grammar.lark}

@@ -26,7 +26,7 @@ payload: $HSEP$ line_text? LF
 line_text: /[^\r\n]+/
 
 insert_target: LID | "EOF" | "BOF"
-range: LID (".." LID)?
+range: LID ".." LID
 
 path: /(?:[^\s\r\n]+|"[^"\r\n]+"|'[^'\r\n]+')/
 LID: /[1-9][0-9]*$HFMT$/