@oh-my-pi/hashline 16.1.17 → 16.1.19

package/dist/types/fs.d.ts

@@ -45,6 +45,18 @@ export declare abstract class Filesystem {
      * snapshots agree on the key without each having to redo the resolution.
      */
     canonicalPath(path: string): string;
+    /**
+     * Whether a section whose authored path is missing may be redirected to
+     * the file its snapshot tag names (tag-based path recovery in
+     * {@link Patcher.prepare}). `resolvedPath` is the canonical path the
+     * redirect would read and write. Default: allow.
+     *
+     * Hosts that grant write privileges by path shape override this to refuse
+     * redirects that could escalate beyond what the caller approved — e.g. an
+     * internal-URL authored target (approved read-only), or a `resolvedPath`
+     * outside the working tree (a sandbox/vault/out-of-tree write).
+     */
+    allowTagPathRecovery(_authoredPath: string, _resolvedPath: string): boolean;
 }
 /**
  * In-memory {@link Filesystem}. Useful for tests, sandboxes, dry-runs, and as

package/dist/types/input.d.ts

@@ -66,6 +66,13 @@ export declare class PatchSection {
      * throw mid-stream.
      */
     applyPartialTo(text: string, blockResolver?: BlockResolver): ApplyResult;
+    /**
+     * A copy of this section rebound to a different target `path`, preserving
+     * the snapshot tag, diff body, and any cached parse result. Used by the
+     * patcher's tag-based path recovery to redirect an edit whose authored
+     * path does not exist onto the file its snapshot tag actually names.
+     */
+    withPath(path: string): PatchSection;
 }
 /**
  * A parsed hashline patch — zero or more {@link PatchSection}s, each rooted

package/dist/types/messages.d.ts

@@ -94,6 +94,14 @@ export declare const HEADTAIL_DRIFT_WARNING = "Applied the `INS.HEAD:`/`INS.TAIL
  * ({@link Patcher.prepare}) and preview/diff paths so both stay in lockstep.
  */
 export declare function missingSnapshotTagMessage(sectionPath: string): string;
+/**
+ * A section named a path that does not exist, but its filename and snapshot
+ * tag together match exactly one file read earlier this session — the model
+ * gave the bare filename (or wrong directory) for a file it just read. The
+ * edit was rebound to that file's full path. Surfaced as a warning so the
+ * model (and user) learn the corrected path and stop reusing the wrong one.
+ */
+export declare function pathRecoveredFromTagMessage(authoredPath: string, resolvedPath: string, tag: string): string;
 /**
  * An anchored edit referenced lines the read that minted the cited tag never
  * displayed (a partial range, or a structural summary that collapsed bodies).

package/dist/types/snapshots.d.ts

@@ -31,6 +31,16 @@ export declare abstract class SnapshotStore {
     abstract head(path: string): Snapshot | null;
     /** Recorded version for `path` whose tag equals `hash`, or `null`. */
     abstract byHash(path: string, hash: string): Snapshot | null;
+    /**
+     * Every retained version whose tag equals `hash`, across all tracked
+     * paths. The patcher uses this to recover the intended file when a section
+     * names a path that does not exist on disk but carries a tag the store
+     * minted — the model mistyped the path of a file it read this session.
+     *
+     * The base returns no matches (recovery disabled); stores that can
+     * enumerate their contents override it to enable tag-based path recovery.
+     */
+    findByHash(_hash: string): Snapshot[];
     /**
      * Record the full normalized text of `path` and return its content tag.
      * `seenLines` (optional) are the 1-indexed lines the producer displayed;
@@ -75,6 +85,7 @@ export declare class InMemorySnapshotStore extends SnapshotStore {
     constructor(options?: InMemorySnapshotStoreOptions);
     head(path: string): Snapshot | null;
     byHash(path: string, hash: string): Snapshot | null;
+    findByHash(hash: string): Snapshot[];
     record(path: string, fullText: string, seenLines?: Iterable<number>): string;
     recordSeenLines(path: string, hash: string, lines: Iterable<number>): void;
     invalidate(path: string): void;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/hashline",
-	"version": "16.1.17",
+	"version": "16.1.19",
 	"description": "Hashline: a compact, line-anchored patch language and applier. Pluggable FS/IO so it works over disk, in-memory, or any custom backend.",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",

package/src/fs.ts

@@ -83,6 +83,21 @@ export abstract class Filesystem {
 	canonicalPath(path: string): string {
 		return path;
 	}
+
+	/**
+	 * Whether a section whose authored path is missing may be redirected to
+	 * the file its snapshot tag names (tag-based path recovery in
+	 * {@link Patcher.prepare}). `resolvedPath` is the canonical path the
+	 * redirect would read and write. Default: allow.
+	 *
+	 * Hosts that grant write privileges by path shape override this to refuse
+	 * redirects that could escalate beyond what the caller approved — e.g. an
+	 * internal-URL authored target (approved read-only), or a `resolvedPath`
+	 * outside the working tree (a sandbox/vault/out-of-tree write).
+	 */
+	allowTagPathRecovery(_authoredPath: string, _resolvedPath: string): boolean {
+		return true;
+	}
 }
 
 /**

package/src/input.ts

@@ -348,6 +348,22 @@ export class PatchSection {
 			? { ...result, warnings: merged }
 			: { text: result.text, firstChangedLine: result.firstChangedLine };
 	}
+
+	/**
+	 * A copy of this section rebound to a different target `path`, preserving
+	 * the snapshot tag, diff body, and any cached parse result. Used by the
+	 * patcher's tag-based path recovery to redirect an edit whose authored
+	 * path does not exist onto the file its snapshot tag actually names.
+	 */
+	withPath(path: string): PatchSection {
+		const next = new PatchSection({
+			path,
+			...(this.fileHash !== undefined ? { fileHash: this.fileHash } : {}),
+			diff: this.diff,
+		});
+		next.#parsed = this.#parsed;
+		return next;
+	}
 }
 
 /**

package/src/messages.ts

@@ -176,6 +176,21 @@ export function missingSnapshotTagMessage(sectionPath: string): string {
 	return `Missing hashline snapshot tag for ${sectionPath}; use \`${HL_FILE_PREFIX}${sectionPath}${HL_FILE_HASH_SEP}tag${HL_FILE_SUFFIX}\` from your latest read/search output. To create a new file, use the write tool.`;
 }
 
+/**
+ * A section named a path that does not exist, but its filename and snapshot
+ * tag together match exactly one file read earlier this session — the model
+ * gave the bare filename (or wrong directory) for a file it just read. The
+ * edit was rebound to that file's full path. Surfaced as a warning so the
+ * model (and user) learn the corrected path and stop reusing the wrong one.
+ */
+export function pathRecoveredFromTagMessage(authoredPath: string, resolvedPath: string, tag: string): string {
+	return (
+		`Path "${authoredPath}" does not exist; matched its filename and snapshot tag ` +
+		`${HL_FILE_HASH_SEP}${tag} to ${resolvedPath} (read earlier this session). Anchor future edits on ` +
+		`${HL_FILE_PREFIX}${resolvedPath}${HL_FILE_HASH_SEP}TAG${HL_FILE_SUFFIX}.`
+	);
+}
+
 /** Compress a line list into a sorted `1-4, 7, 10-12` range string. */
 function formatLineRanges(lines: readonly number[]): string {
 	const sorted = [...new Set(lines)].sort((a, b) => a - b);

package/src/patcher.ts

@@ -22,13 +22,19 @@
  * The patcher itself is stateless across calls; reuse one instance per
  * filesystem configuration.
  */
+import * as path from "node:path";
 import { applyEdits } from "./apply";
 import { hasBlockEdit, resolveBlockEdits } from "./block";
 import { computeFileHash, formatHashlineHeader } from "./format";
 import type { Filesystem, WriteResult } from "./fs";
 import { isNotFound } from "./fs";
 import type { Patch, PatchSection } from "./input";
-import { HEADTAIL_DRIFT_WARNING, missingSnapshotTagMessage, unseenLinesMessage } from "./messages";
+import {
+	HEADTAIL_DRIFT_WARNING,
+	missingSnapshotTagMessage,
+	pathRecoveredFromTagMessage,
+	unseenLinesMessage,
+} from "./messages";
 import { MismatchError } from "./mismatch";
 import { detectLineEnding, type LineEnding, normalizeToLF, restoreLineEndings, stripBom } from "./normalize";
 import { Recovery, type RecoveryResult } from "./recovery";
@@ -245,33 +251,51 @@ export class Patcher {
 	 * tag mismatch ({@link MismatchError}).
 	 */
 	async prepare(section: PatchSection): Promise<PreparedSection> {
-		const { edits, warnings: parseWarnings } = section.parse();
+		const parseWarnings = [...section.parse().warnings];
 		assertSectionHashPresent(section.path, section.fileHash);
 
-		const canonicalPath = this.fs.canonicalPath(section.path);
-		await this.fs.preflightWrite(section.path);
-		const { exists, rawContent } = await this.#tryRead(section.path);
-		if (!exists) {
-			throw new Error(`File not found: ${section.path}. Use the write tool to create new files.`);
+		let target = section;
+		let canonicalPath = this.fs.canonicalPath(target.path);
+		await this.fs.preflightWrite(target.path);
+		let read = await this.#tryRead(target.path);
+
+		// Path recovery: the authored path doesn't exist on disk, but its
+		// filename + snapshot tag may name a file the model read this session
+		// (it supplied a bare filename, or the wrong directory). Rebind to that
+		// file so the edit lands where the tag points, and warn.
+		if (!read.exists) {
+			const recovered = this.#recoverSectionPathFromTag(target, canonicalPath);
+			if (recovered && this.fs.allowTagPathRecovery(target.path, recovered.section.path)) {
+				parseWarnings.push(
+					pathRecoveredFromTagMessage(target.path, recovered.section.path, target.fileHash as string),
+				);
+				target = recovered.section;
+				canonicalPath = recovered.canonicalPath;
+				await this.fs.preflightWrite(target.path);
+				read = await this.#tryRead(target.path);
+			}
+		}
+		if (!read.exists) {
+			throw new Error(`File not found: ${target.path}. Use the write tool to create new files.`);
 		}
 
-		const { bom, text } = stripBom(rawContent);
+		const { bom, text } = stripBom(read.rawContent);
 		const lineEnding = detectLineEnding(text);
 		const normalized = normalizeToLF(text);
 
 		const applyResult = this.#applyWithRecovery({
-			section,
+			section: target,
 			canonicalPath,
-			exists,
+			exists: read.exists,
 			normalized,
-			edits,
+			edits: target.parse().edits,
 		});
 
 		return new PreparedSection(
-			section,
+			target,
 			canonicalPath,
-			exists,
-			rawContent,
+			read.exists,
+			read.rawContent,
 			bom,
 			lineEnding,
 			normalized,
@@ -280,6 +304,38 @@ export class Patcher {
 		);
 	}
 
+	/**
+	 * Resolve a missing authored path to a file read this session by matching
+	 * its filename and snapshot tag. Returns the section rebound to that file's
+	 * canonical path, or `null` when no unique filename+tag match exists.
+	 *
+	 * Resolution requires BOTH the bare filename (basename) and the section tag
+	 * to match a single retained file: a whole-file content hash plus an exact
+	 * filename is a strong identity signal, so the model almost certainly meant
+	 * that file but gave the wrong directory (or only the filename). A tie — two
+	 * retained files sharing the filename and tag — declines recovery. The
+	 * recorded path of the authored file itself is excluded so a deleted file
+	 * does not "recover" onto its own stale snapshot.
+	 */
+	#recoverSectionPathFromTag(
+		section: PatchSection,
+		originalCanonicalPath: string,
+	): { section: PatchSection; canonicalPath: string } | null {
+		if (section.fileHash === undefined) return null;
+		const authoredName = path.basename(section.path);
+		const candidates = [
+			...new Set(
+				this.snapshots
+					.findByHash(section.fileHash)
+					.filter(snapshot => path.basename(snapshot.path) === authoredName)
+					.map(snapshot => snapshot.path),
+			),
+		].filter(candidate => this.fs.canonicalPath(candidate) !== originalCanonicalPath);
+		if (candidates.length !== 1) return null;
+		const resolved = candidates[0];
+		return { section: section.withPath(resolved), canonicalPath: this.fs.canonicalPath(resolved) };
+	}
+
 	/**
 	 * Commit a previously {@link prepare}d section to the filesystem.
 	 * Restores line endings and BOM, writes via the {@link Filesystem}, and

package/src/snapshots.ts

@@ -59,6 +59,19 @@ export abstract class SnapshotStore {
 	/** Recorded version for `path` whose tag equals `hash`, or `null`. */
 	abstract byHash(path: string, hash: string): Snapshot | null;
 
+	/**
+	 * Every retained version whose tag equals `hash`, across all tracked
+	 * paths. The patcher uses this to recover the intended file when a section
+	 * names a path that does not exist on disk but carries a tag the store
+	 * minted — the model mistyped the path of a file it read this session.
+	 *
+	 * The base returns no matches (recovery disabled); stores that can
+	 * enumerate their contents override it to enable tag-based path recovery.
+	 */
+	findByHash(_hash: string): Snapshot[] {
+		return [];
+	}
+
 	/**
 	 * Record the full normalized text of `path` and return its content tag.
 	 * `seenLines` (optional) are the 1-indexed lines the producer displayed;
@@ -142,6 +155,16 @@ export class InMemorySnapshotStore extends SnapshotStore {
 		return history?.find(version => version.hash === hash) ?? null;
 	}
 
+	findByHash(hash: string): Snapshot[] {
+		const matches: Snapshot[] = [];
+		for (const history of this.#versions.values()) {
+			for (const version of history) {
+				if (version.hash === hash) matches.push(version);
+			}
+		}
+		return matches;
+	}
+
 	record(path: string, fullText: string, seenLines?: Iterable<number>): string {
 		const hash = computeFileHash(fullText);
 		// `get` refreshes LRU recency for `path`.