@d3ara1n/pi-hashline-edit 0.1.1 → 0.1.2

package/src/core/parse.ts

@@ -1,166 +0,0 @@
-/**
- * Strict parser: patch string → {@link ParsedPatch}.
- *
- * Core principle — zero guessing: only the canonical format is accepted (correct
- * verb + correct anchor + `+` body rows). Any variant (bare lines, legacy
- * `oldText`/`newText`, `SWAP`/`DEL`, etc.) is rejected and left to the
- * `transforms/normalize-legacy` middleware to normalize before parsing.
- *
- * Format:
- *
- * ```
- * file: <path>
- *
- * replace <line>#<hash>[..<line>#<hash>]:
- * +<text>
- *
- * delete <line>#<hash>[..<line>#<hash>]
- *
- * insert_after <line>#<hash>:
- * +<text>
- *
- * append:
- * +<text>
- * ```
- *
- * @module pi-hashline-edit/core
- */
-
-import type { Anchor, Edit, ParsedPatch, PatchError } from "./types.ts";
-
-export type ParseResult =
-	| { readonly ok: true; readonly patch: ParsedPatch }
-	| { readonly ok: false; readonly error: PatchError };
-
-function parseError(message: string, line?: number): PatchError {
-	return { kind: "parse", message, line };
-}
-
-const ANCHOR_RE = /^(\d+)#([0-9A-Za-z]+)$/;
-
-function parseAnchorStr(s: string): Anchor | null {
-	const m = ANCHOR_RE.exec(s);
-	return m ? { line: Number(m[1]), hash: m[2] } : null;
-}
-
-function parseRangeStr(s: string): { start: Anchor; end?: Anchor } | null {
-	const idx = s.indexOf("..");
-	if (idx === -1) {
-		const a = parseAnchorStr(s);
-		return a ? { start: a } : null;
-	}
-	const a = parseAnchorStr(s.slice(0, idx));
-	const b = parseAnchorStr(s.slice(idx + 2));
-	if (!a || !b) return null;
-	return { start: a, end: b };
-}
-
-type ParsedHeader =
-	| { readonly error: string }
-	| {
-			readonly verb: string;
-			readonly hasBody: boolean;
-			readonly build: (body: string[]) => Edit;
-	  };
-
-/** Parse a single operation header (already trimmed). Trailing colon is optional (for body-bearing verbs). */
-function parseOpHeader(s: string): ParsedHeader {
-	let core = s;
-	if (core.endsWith(":")) core = core.slice(0, -1).trimEnd();
-
-	const sp = core.indexOf(" ");
-	const verb = sp === -1 ? core : core.slice(0, sp);
-	const rest = sp === -1 ? "" : core.slice(sp + 1).trim();
-
-	switch (verb) {
-		case "replace": {
-			const r = parseRangeStr(rest);
-			if (!r) return { error: `replace needs "<line>#<hash>[..<line>#<hash>]", got: "${s}"` };
-			return { verb, hasBody: true, build: (body) => ({ op: "replace", start: r.start, end: r.end, body }) };
-		}
-		case "delete": {
-			const r = parseRangeStr(rest);
-			if (!r) return { error: `delete needs "<line>#<hash>[..<line>#<hash>]", got: "${s}"` };
-			return { verb, hasBody: false, build: () => ({ op: "delete", start: r.start, end: r.end }) };
-		}
-		case "insert_after":
-		case "insert_before": {
-			const a = parseAnchorStr(rest);
-			if (!a) return { error: `${verb} needs "<line>#<hash>", got: "${s}"` };
-			return { verb, hasBody: true, build: (body) => ({ op: verb, anchor: a, body }) };
-		}
-		case "append":
-		case "prepend": {
-			if (rest !== "") return { error: `${verb} takes no anchor, got: "${s}"` };
-			return { verb, hasBody: true, build: (body) => ({ op: verb, body }) };
-		}
-		default:
-			return {
-				error: `unknown verb "${verb}". Use replace / delete / insert_after / insert_before / append / prepend`,
-			};
-	}
-}
-
-/**
- * Strictly parse a patch.
- *
- * @param input patch string (CRLF is normalized to LF automatically)
- * @returns parse result; malformed input returns `ok: false` + PatchError (with the input line number)
- */
-export function parsePatch(input: string): ParseResult {
-	const normalized = input.replace(/\r\n/g, "\n");
-	const lines = normalized.split("\n");
-	const n = lines.length;
-	let i = 0;
-
-	while (i < n && lines[i].trim() === "") i++;
-	if (i >= n) return { ok: false, error: parseError("empty input", 1) };
-
-	const fileMatch = /^file:\s*(.+?)\s*$/i.exec(lines[i]);
-	if (!fileMatch) {
-		return {
-			ok: false,
-			error: parseError(`expected "file: <path>" on first non-blank line, got: "${lines[i]}"`, i + 1),
-		};
-	}
-	const path = fileMatch[1];
-	i++;
-
-	const edits: Edit[] = [];
-	while (i < n) {
-		while (i < n && lines[i].trim() === "") i++;
-		if (i >= n) break;
-
-		const headerLineNo = i + 1;
-		const raw = lines[i];
-		const trimmed = raw.trim();
-
-		if (trimmed.startsWith("+")) {
-			return { ok: false, error: parseError(`stray body row has no preceding header: "${raw}"`, headerLineNo) };
-		}
-
-		const parsed = parseOpHeader(trimmed);
-		if ("error" in parsed) {
-			return { ok: false, error: parseError(parsed.error, headerLineNo) };
-		}
-		i++;
-
-		let body: string[] = [];
-		if (parsed.hasBody) {
-			while (i < n && lines[i].startsWith("+")) {
-				body.push(lines[i].slice(1));
-				i++;
-			}
-			if (body.length === 0) {
-				return {
-					ok: false,
-					error: parseError(`"${parsed.verb}" needs at least one "+TEXT" body row`, headerLineNo),
-				};
-			}
-		}
-
-		edits.push(parsed.build(body));
-	}
-
-	return { ok: true, patch: { path, edits } };
-}

package/src/core/snapshot.test.ts

@@ -1,60 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { splitLines, joinLines, createSnapshot, verifyAnchor } from "./snapshot.ts";
-
-test("splitLines edge cases", () => {
-	assert.deepEqual(splitLines(""), []);
-	assert.deepEqual(splitLines("a"), ["a"]);
-	assert.deepEqual(splitLines("a\nb"), ["a", "b"]);
-	assert.deepEqual(splitLines("a\nb\n"), ["a", "b"]);
-	assert.deepEqual(splitLines("a\n\n"), ["a", ""]);
-	assert.deepEqual(splitLines("\n"), [""]);
-});
-
-test("splitLines strips CRLF \\r", () => {
-	assert.deepEqual(splitLines("a\r\nb\r\n"), ["a", "b"]);
-	assert.deepEqual(splitLines("a\r\nb"), ["a", "b"]);
-});
-
-test("joinLines restores line endings", () => {
-	assert.equal(joinLines(["a", "b"]), "a\nb\n");
-	assert.equal(joinLines([]), "");
-	assert.equal(joinLines(["a", "b"], "crlf"), "a\r\nb\r\n");
-	assert.equal(joinLines(["a", "b"], "lf"), "a\nb\n");
-});
-
-test("createSnapshot records path/text/hashLen", () => {
-	const s = createSnapshot("f.ts", "a\nb\nc\n");
-	assert.equal(s.path, "f.ts");
-	assert.equal(s.text, "a\nb\nc\n");
-	assert.equal(s.lineHashes.length, 3);
-	assert.equal(s.hashLen, 4);
-});
-
-test("createSnapshot custom hashLen", () => {
-	assert.equal(createSnapshot("f", "a\n", 6).hashLen, 6);
-});
-
-test("createSnapshot records lineEnding", () => {
-	assert.equal(createSnapshot("f", "a\nb\n").lineEnding, "lf");
-	assert.equal(createSnapshot("f", "a\r\nb\r\n").lineEnding, "crlf");
-});
-
-test("verifyAnchor match", () => {
-	const s = createSnapshot("f", "a\nb\n");
-	assert.deepEqual(verifyAnchor(s, { line: 2, hash: s.lineHashes[1] }), { ok: true, line: 2 });
-});
-
-test("verifyAnchor hash_not_found", () => {
-	const s = createSnapshot("f", "a\nb\n");
-	const r = verifyAnchor(s, { line: 1, hash: "ZZZZ" });
-	assert.equal(r.ok, false);
-	if (!r.ok) assert.equal(r.error, "hash_not_found");
-});
-
-test("verifyAnchor line_mismatch (drift)", () => {
-	const s = createSnapshot("f", "a\nb\n");
-	const r = verifyAnchor(s, { line: 1, hash: s.lineHashes[1] });
-	assert.equal(r.ok, false);
-	if (!r.ok) assert.equal(r.error, "line_mismatch");
-});

package/src/core/snapshot.ts

@@ -1,84 +0,0 @@
-/**
- * File snapshot and anchor verification.
- *
- * A snapshot records the original text + per-line hash at read time; at apply
- * time it verifies "current file == snapshot" (stale check) and that each
- * anchor's hash matches its line number (guards against the model
- * misremembering).
- *
- * CRLF: splitLines normalizes by stripping the trailing `\r` from each line
- * (hashes are based on clean lines, matching the `\r`-free content the model
- * copies from the display); createSnapshot records the original line ending,
- * and joinLines restores it per the recorded ending — guaranteeing a CRLF file
- * keeps its line endings after edit.
- *
- * @module pi-hashline-edit/core
- */
-
-import { hashFileLines } from "./hash.ts";
-import type { Anchor, FileSnapshot, LineEnding } from "./types.ts";
-
-/**
- * Split text into lines, stripping the trailing `\r` of each line (CRLF
- * normalization, so hashes are based on clean lines).
- *
- * Convention: a trailing newline is treated as the terminator of the last line,
- * not as producing an extra empty trailing line.
- * - `"a\nb\n"` → `["a", "b"]`
- * - `"a\r\nb\r\n"` → `["a", "b"]` (`\r` stripped)
- * - `"a\n\n"` → `["a", ""]`
- * - `""` → `[]`
- */
-export function splitLines(text: string): string[] {
-	if (text === "") return [];
-	const normalized = text.endsWith("\n") ? text.slice(0, -1) : text;
-	return normalized.split("\n").map((l) => (l.endsWith("\r") ? l.slice(0, -1) : l));
-}
-
-/** Detect the dominant line ending of the text (any `\r\n` counts as CRLF). */
-export function detectLineEnding(text: string): LineEnding {
-	return text.includes("\r\n") ? "crlf" : "lf";
-}
-
-/** Join a line array back into text, restoring the given line ending (default LF). Non-empty files end with a newline. */
-export function joinLines(lines: readonly string[], ending: LineEnding = "lf"): string {
-	if (lines.length === 0) return "";
-	const sep = ending === "crlf" ? "\r\n" : "\n";
-	return lines.join(sep) + sep;
-}
-
-/** Create a snapshot for a file: record original text + line ending + per-line context-aware hash. */
-export function createSnapshot(path: string, text: string, len = 4): FileSnapshot {
-	const lines = splitLines(text);
-	const lineHashes = hashFileLines(lines, len);
-	return { path, lineHashes, text, hashLen: len, lineEnding: detectLineEnding(text) };
-}
-
-/** Anchor verification result. */
-export type AnchorVerifyResult =
-	| { readonly ok: true; readonly line: number }
-	| {
-			readonly ok: false;
-			readonly error: "hash_not_found" | "line_mismatch" | "collision";
-			/** Line number(s) where the hash actually appears (1-based). */
-			readonly found?: readonly number[];
-	  };
-
-/**
- * Verify an anchor against the snapshot.
- *
- * - hash is unique and the line number matches → `ok`
- * - hash is unique but the line number differs → `line_mismatch` (`found` gives the real line number; drift, handled by the relocate middleware)
- * - hash appears at multiple lines → `collision` (`found` gives all positions)
- * - hash does not exist → `hash_not_found` (file changed, needs re-read)
- */
-export function verifyAnchor(snapshot: FileSnapshot, anchor: Anchor): AnchorVerifyResult {
-	const found: number[] = [];
-	for (let i = 0; i < snapshot.lineHashes.length; i++) {
-		if (snapshot.lineHashes[i] === anchor.hash) found.push(i + 1);
-	}
-	if (found.length === 0) return { ok: false, error: "hash_not_found" };
-	if (found.length > 1) return { ok: false, error: "collision", found };
-	if (found[0] !== anchor.line) return { ok: false, error: "line_mismatch", found };
-	return { ok: true, line: anchor.line };
-}