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

package/src/edit/hashline/diff.ts

@@ -0,0 +1,88 @@
+/**
+ * Read-only hashline diff preview helpers used by the streaming edit
+ * renderer. Reads the target file, parses + applies the section's edits in
+ * memory (no FS write, no LSP writethrough), then hands the before/after
+ * pair to {@link generateDiffString} so the renderer can show the diff
+ * while the tool call is still streaming.
+ *
+ * Validation is intentionally light: only the section file hash is checked
+ * (so the preview goes red when anchors are stale), no plan-mode guards
+ * and no auto-generated-file refusal — those belong on the write path.
+ */
+import {
+	applyEdits,
+	computeFileHash,
+	Patch as HashlinePatch,
+	normalizeToLF,
+	type Patch,
+	type PatchSection,
+	stripBom,
+} from "@oh-my-pi/hashline";
+import { resolveToCwd } from "../../tools/path-utils";
+import { generateDiffString } from "../diff";
+import { readEditFileText } from "../read-file";
+
+export interface HashlineDiffOptions {
+	autoDropPureInsertDuplicates?: boolean;
+}
+
+async function readSectionText(absolutePath: string, sectionPath: string): Promise<string> {
+	try {
+		return await readEditFileText(absolutePath, sectionPath);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(message || `Unable to read ${sectionPath}`);
+	}
+}
+
+function hasAnchorScoped(section: PatchSection): boolean {
+	return section.hasAnchorScopedEdit;
+}
+
+function validateSectionHash(section: PatchSection, text: string): string | null {
+	if (section.fileHash === undefined) {
+		return hasAnchorScoped(section)
+			? `Missing hashline file hash for anchored edit to ${section.path}; use \`¶${section.path}#hash\` from your latest read.`
+			: null;
+	}
+	const currentHash = computeFileHash(text);
+	if (currentHash === section.fileHash) return null;
+	return `Hashline file hash mismatch for ${section.path}: section is bound to #${section.fileHash}, but current file hashes to #${currentHash}; re-read and try again.`;
+}
+
+export async function computeHashlineSectionDiff(
+	section: PatchSection,
+	cwd: string,
+	options: HashlineDiffOptions = {},
+): Promise<{ diff: string; firstChangedLine: number | undefined } | { error: string }> {
+	try {
+		const absolutePath = resolveToCwd(section.path, cwd);
+		const rawContent = await readSectionText(absolutePath, section.path);
+		const { text: content } = stripBom(rawContent);
+		const normalized = normalizeToLF(content);
+		const hashError = validateSectionHash(section, normalized);
+		if (hashError) return { error: hashError };
+		const result = applyEdits(normalized, [...section.edits], options);
+		if (normalized === result.text) return { error: `No changes would be made to ${section.path}.` };
+		return generateDiffString(normalized, result.text);
+	} catch (err) {
+		return { error: err instanceof Error ? err.message : String(err) };
+	}
+}
+
+export async function computeHashlineDiff(
+	input: { input: string; path?: string },
+	cwd: string,
+	options: HashlineDiffOptions = {},
+): Promise<{ diff: string; firstChangedLine: number | undefined } | { error: string }> {
+	let patch: Patch;
+	try {
+		patch = HashlinePatch.parse(input.input, { cwd, path: input.path });
+	} catch (err) {
+		return { error: err instanceof Error ? err.message : String(err) };
+	}
+	if (patch.sections.length !== 1) {
+		return { error: "Streaming diff preview supports exactly one hashline section." };
+	}
+	return computeHashlineSectionDiff(patch.sections[0], cwd, options);
+}

package/src/edit/hashline/execute.ts

@@ -0,0 +1,188 @@
+/**
+ * Coding-agent runner that drives the hashline {@link Patcher} on behalf of
+ * the `edit` tool. Converts a `{input, path?}` tool-call payload into a
+ * fully-applied patch, wraps the result in the agent's
+ * {@link AgentToolResult} shape, and attaches LSP diagnostics + `outputMeta`
+ * for the renderer.
+ *
+ * Multi-section patches are preflighted up front via {@link Patcher.prepare}
+ * so a partial batch never lands; the commit loop then narrows the LSP
+ * batch's `flush` flag to true only for the final write so diagnostics
+ * round-trip once.
+ */
+import {
+	buildCompactDiffPreview,
+	MismatchError as HashlineMismatchError,
+	Patch,
+	Patcher,
+	type PatchSectionResult,
+	type PreparedSection,
+} from "@oh-my-pi/hashline";
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { FileDiagnosticsResult, WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
+import type { ToolSession } from "../../tools";
+import { outputMeta } from "../../tools/output-meta";
+import { generateDiffString } from "../diff";
+import { getFileSnapshotStore } from "../file-snapshot-store";
+import type { EditToolDetails, EditToolPerFileResult, LspBatchRequest } from "../renderer";
+import { HashlineFilesystem } from "./filesystem";
+import { type HashlineParams, hashlineEditParamsSchema } from "./params";
+
+export interface ExecuteHashlineSingleOptions {
+	session: ToolSession;
+	input: string;
+	path?: string;
+	signal?: AbortSignal;
+	batchRequest?: LspBatchRequest;
+	writethrough: WritethroughCallback;
+	beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
+}
+
+function getHashlineApplyOptions(session: ToolSession): { autoDropPureInsertDuplicates: boolean } {
+	return {
+		autoDropPureInsertDuplicates: session.settings.get("edit.hashlineAutoDropPureInsertDuplicates"),
+	};
+}
+
+function noChangeDiagnostic(path: string): string {
+	return `Edits to ${path} resulted in no changes being made.`;
+}
+
+function assertUniqueCanonicalPaths(prepared: readonly PreparedSection[]): void {
+	const seen = new Map<string, string>();
+	for (const entry of prepared) {
+		const previous = seen.get(entry.canonicalPath);
+		if (previous !== undefined) {
+			throw new Error(
+				`Multiple hashline sections resolve to the same file (${previous} and ${entry.section.path}). Merge their ops under one header before applying.`,
+			);
+		}
+		seen.set(entry.canonicalPath, entry.section.path);
+	}
+}
+
+function narrowBatchRequest(outer: LspBatchRequest | undefined, isLast: boolean): LspBatchRequest | undefined {
+	if (!outer) return undefined;
+	return { id: outer.id, flush: isLast && outer.flush };
+}
+
+interface RenderedSection {
+	toolResult: AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema>;
+	perFileResult: EditToolPerFileResult;
+}
+
+function renderSection(result: PatchSectionResult, diagnostics: FileDiagnosticsResult | undefined): RenderedSection {
+	if (result.op === "noop") {
+		const toolResult: AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema> = {
+			content: [{ type: "text", text: noChangeDiagnostic(result.path) }],
+			details: { diff: "", op: "update", meta: outputMeta().get() },
+		};
+		return {
+			toolResult,
+			perFileResult: { path: result.path, diff: "", op: "update" },
+		};
+	}
+
+	const diff = generateDiffString(result.before, result.after);
+	const preview = buildCompactDiffPreview(diff.diff);
+	const meta = outputMeta()
+		.diagnostics(diagnostics?.summary ?? "", diagnostics?.messages ?? [])
+		.get();
+
+	const warningsBlock = result.warnings.length > 0 ? `\n\nWarnings:\n${result.warnings.join("\n")}` : "";
+	const previewBlock = preview.preview ? `\n${preview.preview}` : "";
+	const headline = preview.preview
+		? `${result.path}:`
+		: result.op === "create"
+			? `Created ${result.path}`
+			: `Updated ${result.path}`;
+
+	const firstChangedLine = result.firstChangedLine ?? diff.firstChangedLine;
+	return {
+		toolResult: {
+			content: [{ type: "text", text: `${headline}\n${result.header}${previewBlock}${warningsBlock}` }],
+			details: {
+				diff: diff.diff,
+				firstChangedLine,
+				diagnostics,
+				op: result.op,
+				meta,
+			},
+		},
+		perFileResult: {
+			path: result.path,
+			diff: diff.diff,
+			firstChangedLine,
+			diagnostics,
+			op: result.op,
+		},
+	};
+}
+
+export async function executeHashlineSingle(
+	options: ExecuteHashlineSingleOptions,
+): Promise<AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema>> {
+	const patch = Patch.parse(options.input, { cwd: options.session.cwd, path: options.path });
+	if (patch.sections.length === 0) {
+		throw new Error("No hashline sections found in input.");
+	}
+
+	const fs = new HashlineFilesystem({
+		session: options.session,
+		writethrough: options.writethrough,
+		beginDeferredDiagnosticsForPath: options.beginDeferredDiagnosticsForPath,
+		signal: options.signal,
+		batchRequest: options.batchRequest,
+	});
+	const snapshots = getFileSnapshotStore(options.session);
+	const applyOptions = getHashlineApplyOptions(options.session);
+	const patcher = new Patcher({ fs, snapshots, applyOptions });
+
+	// Single-section fast path: prepare, commit, render.
+	if (patch.sections.length === 1) {
+		fs.setBatchRequest(narrowBatchRequest(options.batchRequest, true));
+		const prepared = await patcher.prepare(patch.sections[0]);
+		const sectionResult = await patcher.commit(prepared);
+		if (sectionResult.op === "noop") {
+			return renderSection(sectionResult, undefined).toolResult;
+		}
+		return renderSection(sectionResult, fs.consumeDiagnostics(sectionResult.path)).toolResult;
+	}
+
+	// Multi-section: prepare every section up front so we fail fast before
+	// any write hits the filesystem.
+	const prepared: PreparedSection[] = [];
+	for (const section of patch.sections) prepared.push(await patcher.prepare(section));
+	assertUniqueCanonicalPaths(prepared);
+	for (const entry of prepared) {
+		if (entry.isNoop) throw new Error(noChangeDiagnostic(entry.section.path));
+	}
+	// Then commit each one, narrowing the LSP batch flush flag to the final
+	// section only. A no-op apply mid-batch is treated as a hard failure —
+	// the model authored anchors that match the current file content.
+	const rendered: RenderedSection[] = [];
+	for (let i = 0; i < prepared.length; i++) {
+		const isLast = i === prepared.length - 1;
+		fs.setBatchRequest(narrowBatchRequest(options.batchRequest, isLast));
+		const sectionResult = await patcher.commit(prepared[i]);
+		if (sectionResult.op === "noop") throw new Error(noChangeDiagnostic(sectionResult.path));
+		rendered.push(renderSection(sectionResult, fs.consumeDiagnostics(sectionResult.path)));
+	}
+
+	return {
+		content: [
+			{
+				type: "text",
+				text: rendered
+					.map(r => r.toolResult.content.map(part => (part.type === "text" ? part.text : "")).join("\n"))
+					.join("\n\n"),
+			},
+		],
+		details: {
+			diff: rendered.map(r => r.toolResult.details?.diff ?? "").join("\n"),
+			perFileResults: rendered.map(r => r.perFileResult),
+		},
+	};
+}
+
+export { HashlineMismatchError, type HashlineParams, hashlineEditParamsSchema };

package/src/edit/hashline/filesystem.ts

@@ -0,0 +1,129 @@
+/**
+ * Coding-agent specific {@link Filesystem} adapter for the hashline patcher.
+ *
+ * Wires hashline's storage abstraction to the agent runtime:
+ *
+ * - Section paths are resolved through the plan-mode redirect so a bare
+ *   `PLAN.md` lands at the canonical session artifact location.
+ * - Reads go through `readEditFileText` (notebook-aware) and the
+ *   auto-generated-file guard.
+ * - Writes go through `serializeEditFileText` (notebook-aware) and the
+ *   LSP writethrough, with FS-scan cache invalidation on success. The
+ *   resulting `FileDiagnosticsResult` is captured per-path so the
+ *   orchestrator can attach it to the tool result.
+ *
+ * Construct one per `executeHashlineSingle` call: per-section state
+ * (batch request, diagnostics) lives on the instance and isn't safe to
+ * share across concurrent edit tools.
+ */
+import { Filesystem, NotFoundError, type WriteResult } from "@oh-my-pi/hashline";
+import { isEnoent } from "@oh-my-pi/pi-utils";
+import type { FileDiagnosticsResult, WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
+import type { ToolSession } from "../../tools";
+import { assertEditableFileContent } from "../../tools/auto-generated-guard";
+import { invalidateFsScanAfterWrite } from "../../tools/fs-cache-invalidation";
+import { enforcePlanModeWrite, resolvePlanPath } from "../../tools/plan-mode-guard";
+import { readEditFileText, serializeEditFileText } from "../read-file";
+import type { LspBatchRequest } from "../renderer";
+
+export interface HashlineFilesystemOptions {
+	session: ToolSession;
+	writethrough: WritethroughCallback;
+	beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
+	signal?: AbortSignal;
+	/**
+	 * Outer LSP batch request inherited from the tool-call context. The
+	 * orchestrator narrows this per-section (flush only on the final write)
+	 * via {@link HashlineFilesystem.setBatchRequest}.
+	 */
+	batchRequest?: LspBatchRequest;
+}
+
+export class HashlineFilesystem extends Filesystem {
+	readonly session: ToolSession;
+	readonly #writethrough: WritethroughCallback;
+	readonly #beginDeferredDiagnosticsForPath: (path: string) => WritethroughDeferredHandle;
+	readonly #signal: AbortSignal | undefined;
+	#batchRequest: LspBatchRequest | undefined;
+	#diagnosticsByPath = new Map<string, FileDiagnosticsResult | undefined>();
+
+	constructor(options: HashlineFilesystemOptions) {
+		super();
+		this.session = options.session;
+		this.#writethrough = options.writethrough;
+		this.#beginDeferredDiagnosticsForPath = options.beginDeferredDiagnosticsForPath;
+		this.#signal = options.signal;
+		this.#batchRequest = options.batchRequest;
+	}
+
+	/**
+	 * Set the LSP batch request used for the next {@link writeText} call.
+	 * Multi-section orchestrators flip the `flush` flag to true before the
+	 * final section so LSP diagnostics flush in one round-trip.
+	 */
+	setBatchRequest(batchRequest: LspBatchRequest | undefined): void {
+		this.#batchRequest = batchRequest;
+	}
+
+	/**
+	 * Look up (and clear) the diagnostics captured by the most-recent
+	 * {@link writeText} call for `path`. Returns `undefined` if no write
+	 * has happened or the writethrough returned no diagnostics.
+	 */
+	consumeDiagnostics(path: string): FileDiagnosticsResult | undefined {
+		const value = this.#diagnosticsByPath.get(path);
+		this.#diagnosticsByPath.delete(path);
+		return value;
+	}
+
+	resolveAbsolute(relativePath: string): string {
+		return resolvePlanPath(this.session, relativePath);
+	}
+
+	canonicalPath(relativePath: string): string {
+		return this.resolveAbsolute(relativePath);
+	}
+
+	async readText(relativePath: string): Promise<string> {
+		const absolutePath = this.resolveAbsolute(relativePath);
+		let content: string;
+		try {
+			content = await readEditFileText(absolutePath, relativePath);
+		} catch (error) {
+			if (isEnoent(error)) throw new NotFoundError(relativePath, error);
+			if (error instanceof Error && error.message === `File not found: ${relativePath}`) {
+				throw new NotFoundError(relativePath, error);
+			}
+			throw error;
+		}
+		// Refuse edits against generated files (lockfiles, models.json, …).
+		assertEditableFileContent(content, relativePath);
+		return content;
+	}
+
+	async preflightWrite(relativePath: string): Promise<void> {
+		enforcePlanModeWrite(this.session, relativePath, { op: "update" });
+	}
+
+	async writeText(relativePath: string, content: string): Promise<WriteResult> {
+		await this.preflightWrite(relativePath);
+		const absolutePath = this.resolveAbsolute(relativePath);
+		const finalContent = await serializeEditFileText(absolutePath, relativePath, content);
+		const diagnostics = await this.#writethrough(
+			absolutePath,
+			finalContent,
+			this.#signal,
+			Bun.file(absolutePath),
+			this.#batchRequest,
+			dst => (dst === absolutePath ? this.#beginDeferredDiagnosticsForPath(absolutePath) : undefined),
+		);
+		invalidateFsScanAfterWrite(absolutePath);
+		this.#diagnosticsByPath.set(relativePath, diagnostics);
+		return { text: finalContent };
+	}
+
+	async exists(relativePath: string): Promise<boolean> {
+		const absolutePath = this.resolveAbsolute(relativePath);
+		return Bun.file(absolutePath).exists();
+	}
+}

package/src/edit/hashline/index.ts

@@ -0,0 +1,4 @@
+export * from "./diff";
+export * from "./execute";
+export * from "./filesystem";
+export * from "./params";

package/src/edit/hashline/params.ts

@@ -0,0 +1,11 @@
+/**
+ * Zod schema for the `edit` tool's hashline mode payload. The schema is
+ * deliberately permissive (`.passthrough()`) so providers can attach extra
+ * keys without rejection; only `input` is required and `path` is an
+ * optional fallback used when the input lacks a `¶PATH#HASH` header.
+ */
+import * as z from "zod/v4";
+
+export const hashlineEditParamsSchema = z.object({ input: z.string(), path: z.string().optional() }).passthrough();
+
+export type HashlineParams = z.infer<typeof hashlineEditParamsSchema>;

package/src/edit/index.ts

@@ -1,13 +1,8 @@
+import { MismatchError as HashlineMismatchError } from "@oh-my-pi/hashline";
+import hashlineGrammar from "@oh-my-pi/hashline/grammar.lark" with { type: "text" };
+import hashlineDescription from "@oh-my-pi/hashline/prompt.md" with { type: "text" };
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { prompt } from "@oh-my-pi/pi-utils";
-import {
-	executeHashlineSingle,
-	HashlineMismatchError,
-	type HashlineParams,
-	hashlineEditParamsSchema,
-} from "../hashline";
-import hashlineGrammarTemplate from "../hashline/grammar.lark" with { type: "text" };
-import { resolveHashlineGrammarPlaceholders } from "../hashline/hash";
 import {
 	createLspWritethrough,
 	type FileDiagnosticsResult,
@@ -16,28 +11,25 @@ import {
 	writethroughNoop,
 } from "../lsp";
 import applyPatchDescription from "../prompts/tools/apply-patch.md" with { type: "text" };
-import hashlineDescription from "../prompts/tools/hashline.md" with { type: "text" };
 import patchDescription from "../prompts/tools/patch.md" with { type: "text" };
 import replaceDescription from "../prompts/tools/replace.md" with { type: "text" };
 import type { ToolSession } from "../tools";
 import { truncateForPrompt } from "../tools/approval";
 import { isInternalUrlPath } from "../tools/path-utils";
 import { type EditMode, normalizeEditMode, resolveEditMode } from "../utils/edit-mode";
+import { executeHashlineSingle, type HashlineParams, hashlineEditParamsSchema } from "./hashline";
 import { type ApplyPatchParams, applyPatchSchema, expandApplyPatchToEntries } from "./modes/apply-patch";
 import applyPatchGrammar from "./modes/apply-patch.lark" with { type: "text" };
 import { executePatchSingle, type PatchEditEntry, type PatchParams, patchEditSchema } from "./modes/patch";
 import { executeReplaceSingle, type ReplaceEditEntry, type ReplaceParams, replaceEditSchema } from "./modes/replace";
 import { type EditToolDetails, type EditToolPerFileResult, getLspBatchRequest, type LspBatchRequest } from "./renderer";
 
+export * from "@oh-my-pi/hashline";
 export { DEFAULT_EDIT_MODE, type EditMode, normalizeEditMode } from "../utils/edit-mode";
 export * from "./apply-patch";
 export * from "./diff";
-export * from "./file-read-cache";
-
-// Resolve hashline grammar placeholders from the TypeScript constants.
-const hashlineGrammar = resolveHashlineGrammarPlaceholders(hashlineGrammarTemplate);
-
-export * from "../hashline";
+export * from "./file-snapshot-store";
+export * from "./hashline";
 export * from "./modes/apply-patch";
 export * from "./modes/patch";
 export * from "./modes/replace";

package/src/edit/normalize.ts

@@ -1,51 +1,21 @@
 /**
  * Text normalization utilities for the edit tool.
  *
- * Handles line endings, BOM, whitespace, and Unicode normalization.
+ * Whitespace, Unicode, and indentation helpers. Line-ending and BOM
+ * primitives live in `@oh-my-pi/hashline` and are re-exported here so
+ * existing consumers see one stable surface.
  */
 
 import { padding } from "@oh-my-pi/pi-tui";
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Line Ending Utilities
-// ═══════════════════════════════════════════════════════════════════════════
-
-export type LineEnding = "\r\n" | "\n";
-
-/** Detect the predominant line ending in content */
-export function detectLineEnding(content: string): LineEnding {
-	const crlfIdx = content.indexOf("\r\n");
-	const lfIdx = content.indexOf("\n");
-	if (lfIdx === -1) return "\n";
-	if (crlfIdx === -1) return "\n";
-	return crlfIdx < lfIdx ? "\r\n" : "\n";
-}
-
-/** Normalize all line endings to LF */
-export function normalizeToLF(text: string): string {
-	return text.replace(/\r\n?/g, "\n");
-}
-
-/** Restore line endings to the specified type */
-export function restoreLineEndings(text: string, ending: LineEnding): string {
-	return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// BOM Handling
-// ═══════════════════════════════════════════════════════════════════════════
-
-export interface BomResult {
-	/** The BOM character if present, empty string otherwise */
-	bom: string;
-	/** The text without the BOM */
-	text: string;
-}
-
-/** Strip UTF-8 BOM if present */
-export function stripBom(content: string): BomResult {
-	return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
-}
+export {
+	type BomResult,
+	detectLineEnding,
+	type LineEnding,
+	normalizeToLF,
+	restoreLineEndings,
+	stripBom,
+} from "@oh-my-pi/hashline";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Whitespace Utilities

package/src/edit/renderer.ts

@@ -2,11 +2,11 @@
  * Edit tool renderer and LSP batching helpers.
  */
 
+import { HL_FILE_PREFIX } from "@oh-my-pi/hashline";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text, visibleWidth, wrapTextWithAnsi } from "@oh-my-pi/pi-tui";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import { HL_FILE_PREFIX } from "../hashline/hash";
 import type { FileDiagnosticsResult } from "../lsp";
 import { renderDiff as renderDiffColored } from "../modes/components/diff";
 import { getLanguageFromPath, type Theme } from "../modes/theme/theme";

package/src/edit/streaming.ts

@@ -13,22 +13,21 @@
  * the injected `editMode` rather than probing argument shape.
  */
 
-import { sanitizeText } from "@oh-my-pi/pi-utils";
 import {
 	ABORT_MARKER,
 	BEGIN_PATCH_MARKER,
-	computeHashlineDiff,
-	computeHashlineSectionDiff,
 	containsRecognizableHashlineOperations,
 	END_PATCH_MARKER,
-	type HashlineInputSection,
-	HashlineTokenizer,
-	splitHashlineInputs,
-} from "../hashline";
+	type PatchSection as HashlineInputSection,
+	Patch as HashlinePatch,
+	Tokenizer as HashlineTokenizer,
+} from "@oh-my-pi/hashline";
+import { sanitizeText } from "@oh-my-pi/pi-utils";
 import type { Theme } from "../modes/theme/theme";
 import { replaceTabs, truncateToWidth } from "../tools/render-utils";
 import { type EditMode, resolveEditMode } from "../utils/edit-mode";
 import { computeEditDiff, type DiffError, type DiffResult } from "./diff";
+import { computeHashlineDiff, computeHashlineSectionDiff } from "./hashline/diff";
 import { type ApplyPatchEntry, expandApplyPatchToEntries, expandApplyPatchToPreviewEntries } from "./modes/apply-patch";
 import { computePatchDiff, type PatchEditEntry } from "./modes/patch";
 import type { ReplaceEditEntry } from "./modes/replace";
@@ -438,9 +437,9 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 		}
 		ctx.signal.throwIfAborted();
 
-		let sections: HashlineInputSection[];
+		let sections: readonly HashlineInputSection[];
 		try {
-			sections = splitHashlineInputs(input, { cwd: ctx.cwd, path: args.path });
+			sections = HashlinePatch.parse(input, { cwd: ctx.cwd, path: args.path }).sections;
 		} catch {
 			// Single-section fallback keeps the original error rendering for the
 			// "haven't typed `¶ PATH` yet" case.

package/src/index.ts

@@ -26,7 +26,6 @@ export * from "./extensibility/extensions";
 export * from "./extensibility/skills";
 // Slash commands
 export { type FileSlashCommand, loadSlashCommands as discoverSlashCommands } from "./extensibility/slash-commands";
-export * from "./hashline";
 export type * from "./lsp";
 // Main entry point
 export * from "./main";