pi-hashline-edit-pro 0.15.1 → 0.15.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "0.15.1",
+  "version": "0.15.3",
   "description": "Strict hashline read/replace tool for pi-coding-agent with hash-anchored edits (3-char, 18-bit, perfect hashing)",
   "main": "index.ts",
   "repository": {

package/src/hashline/hash.ts

@@ -124,7 +124,7 @@ export function _lineHashesPure(content: string): string[] {
 export async function lineHashes(
   content: string,
   path?: string,
-  previous?: { content: string; hashes: string[] },
+  previous?: { content: string; hashes: string[]; removedHashes?: Set<string> },
 ): Promise<string[]> {
   if (!path) {
     return _lineHashesPure(content);
@@ -137,6 +137,7 @@ export async function lineHashes(
     const newHashes = mapStableHashes(
       previous.content, previous.hashes,
       content,
+      previous.removedHashes,
     );
     store.snapshots[path] = { content, hashes: newHashes };
     await saveHashStore(store);
@@ -157,42 +158,63 @@ export async function lineHashes(
 }
 
 /**
- * Diff old content against new content, preserving hashes for unchanged
- * lines. New/changed lines allocate fresh hashes with collision avoidance.
+ * Maps old hashes to new positions using hash-aware content matching.
+ * Unlike Diff.diffLines (which is content-only and cannot distinguish
+ * identical lines at different positions), this algorithm uses the
+ * removedHashes set to disambiguate: when a line appears multiple times
+ * in the old content and one occurrence was targeted by the edit,
+ * the surviving occurrence is matched to the non-removed hash.
+ * New/changed lines allocate fresh hashes with collision avoidance.
  */
 function mapStableHashes(
   oldContent: string,
   oldHashes: string[],
   newContent: string,
+  removedHashes?: Set<string>,
 ): string[] {
   const newLines = newContent.split("\n");
   const newHashes = new Array<string>(newLines.length);
   const used = new Set<string>();
 
-  const parts = Diff.diffLines(oldContent, newContent);
-  let oldIdx = 0;
-  let newIdx = 0;
-
-  for (const part of parts) {
-    const raw = part.value.split("\n");
-    if (raw[raw.length - 1] === "") raw.pop();
-    const count = raw.length;
-    if (count === 0) continue;
-
-    if (part.added) {
-      newIdx += count;
-    } else if (part.removed) {
-      oldIdx += count;
+  // Build a map from line content to list of (index, hash) for the old content.
+  // We process occurrences left-to-right so that matching preserves order.
+  const contentMap = new Map<string, { index: number; hash: string }[]>();
+  const oldLines = oldContent.split("\n");
+  for (let i = 0; i < oldLines.length; i++) {
+    const line = oldLines[i]!;
+    const entry = { index: i, hash: oldHashes[i]! };
+    const list = contentMap.get(line);
+    if (list) {
+      list.push(entry);
     } else {
-      // unchanged — copy hashes
-      for (let k = 0; k < count; k++) {
-        const h = oldHashes[oldIdx]!;
-        newHashes[newIdx] = h;
-        used.add(h);
-        oldIdx++;
-        newIdx++;
+      contentMap.set(line, [entry]);
+    }
+  }
+
+  // Match each new line to an old occurrence by content.
+  // For lines with duplicate content, prefer occurrences whose hash
+  // was NOT targeted by the edit (those are the survivors).
+  for (let i = 0; i < newLines.length; i++) {
+    const line = newLines[i]!;
+    const candidates = contentMap.get(line);
+    if (!candidates || candidates.length === 0) continue;
+
+    // Find the best match: prefer a non-removed occurrence.
+    // If all remaining occurrences are removed, use the first one anyway
+    // (it will get a fresh hash in the fill step since its hash is in used+removed).
+    let bestIdx = 0;
+    if (removedHashes && removedHashes.size > 0) {
+      for (let j = 0; j < candidates.length; j++) {
+        if (!removedHashes.has(candidates[j]!.hash)) {
+          bestIdx = j;
+          break;
+        }
       }
     }
+
+    const match = candidates.splice(bestIdx, 1)[0]!;
+    newHashes[i] = match.hash;
+    used.add(match.hash);
   }
 
   // Fill remaining (new/changed) lines with fresh hashes

package/src/replace-diff.ts

@@ -45,10 +45,25 @@ export function genDiff(
   newContent: string,
   contextLines = 2,
   newContentHashes?: string[],
+  oldHashes?: string[],
 ): { diff: string; firstChangedLine: number | undefined } {
-  const parts = Diff.diffLines(oldContent, newContent);
-  const output: string[] = [];
+  // Annotate each line with its hash so Diff.diffLines can distinguish
+  // identical lines at different positions. The \0 separator cannot appear
+  // in valid text file content.
+  const oldLines = oldContent.split("\n");
+  const effectiveOldHashes = oldHashes ?? _lineHashesPure(oldContent);
+  const annotatedOld = oldLines
+    .map((line, i) => `${line}\0${effectiveOldHashes[i] ?? ""}`)
+    .join("\n");
+
+  const newLines = newContent.split("\n");
   const effectiveNewHashes = newContentHashes ?? _lineHashesPure(newContent);
+  const annotatedNew = newLines
+    .map((line, i) => `${line}\0${effectiveNewHashes[i] ?? ""}`)
+    .join("\n");
+
+  const parts = Diff.diffLines(annotatedOld, annotatedNew);
+  const output: string[] = [];
   let oldLineNum = 1;
   let newLineNum = 1;
   let lastWasChange = false;
@@ -58,18 +73,21 @@ export function genDiff(
     const part = parts[i]!;
     const raw = part.value.split("\n");
     if (raw[raw.length - 1] === "") raw.pop();
+    // Strip \0hash annotation from each line for display
+    const displayLines = raw.map((l) => {
+      const nullIdx = l.indexOf("\0");
+      return nullIdx >= 0 ? l.slice(0, nullIdx) : l;
+    });
 
     if (part.added || part.removed) {
       if (firstChangedLine === undefined) firstChangedLine = newLineNum;
-      for (const line of raw) {
+      for (let k = 0; k < displayLines.length; k++) {
         if (part.added) {
           const hash = effectiveNewHashes[newLineNum - 1];
-          output.push(fmtDiffLine("+", line, hash));
+          output.push(fmtDiffLine("+", displayLines[k]!, hash));
           newLineNum++;
         } else {
-          output.push(
-            fmtDiffLine("-", line, undefined),
-          );
+          output.push(fmtDiffLine("-", displayLines[k]!, undefined));
           oldLineNum++;
         }
       }
@@ -80,18 +98,18 @@ export function genDiff(
     const nextPartIsChange =
       i < parts.length - 1 && (parts[i + 1]!.added || parts[i + 1]!.removed);
     if (lastWasChange || nextPartIsChange) {
-      let linesToShow = raw;
+      let linesToShow = displayLines;
       let skipStart = 0;
       let skipEnd = 0;
       let skipMiddle = 0;
 
       if (!lastWasChange) {
-        skipStart = Math.max(0, raw.length - contextLines);
-        linesToShow = raw.slice(skipStart);
-      } else if (nextPartIsChange && raw.length > contextLines * 2) {
-        const tail = raw.slice(-contextLines);
-        linesToShow = [...raw.slice(0, contextLines), "__ELLIPSIS__", ...tail];
-        skipMiddle = raw.length - contextLines * 2;
+        skipStart = Math.max(0, displayLines.length - contextLines);
+        linesToShow = displayLines.slice(skipStart);
+      } else if (nextPartIsChange && displayLines.length > contextLines * 2) {
+        const tail = displayLines.slice(-contextLines);
+        linesToShow = [...displayLines.slice(0, contextLines), "__ELLIPSIS__", ...tail];
+        skipMiddle = displayLines.length - contextLines * 2;
       } else if (linesToShow.length > contextLines) {
         skipEnd = linesToShow.length - contextLines;
         linesToShow = linesToShow.slice(0, contextLines);
@@ -111,13 +129,12 @@ export function genDiff(
         }
         const hash = effectiveNewHashes[newLineNum - 1];
         output.push(fmtDiffLine(" ", line, hash));
-
         oldLineNum++;
         newLineNum++;
       }
     } else {
-      oldLineNum += raw.length;
-      newLineNum += raw.length;
+      oldLineNum += displayLines.length;
+      newLineNum += displayLines.length;
     }
     lastWasChange = false;
   }

package/src/replace-flat.ts

@@ -238,6 +238,7 @@ export function buildToolDef(): ToolDef {
 
         const {
           originalNormalized,
+          originalHashes,
           result,
           bom,
           originalEnding,
@@ -294,13 +295,13 @@ export function buildToolDef(): ToolDef {
         const successInput = {
           path,
           originalNormalized,
+          originalHashes,
           result,
           resultHashes,
           warnings,
           snapshotId: updatedSnapshotId,
           editMeta,
         };
-
         return buildChanged(successInput);
       });
     },

package/src/replace-response.ts

@@ -40,13 +40,14 @@ export interface NoopInput {
 }
 
 export interface SuccessInput {
-	path: string;
-	originalNormalized: string;
-	result: string;
-	resultHashes: string[];
-	warnings: string[] | undefined;
-	snapshotId: string;
-	editMeta: RMeta;
+  path: string;
+  originalNormalized: string;
+  originalHashes: string[];
+  result: string;
+  resultHashes: string[];
+  warnings: string[] | undefined;
+  snapshotId: string;
+  editMeta: RMeta;
 }
 
 function cntDiff(diff: string, marker: "+" | "-"): number {
@@ -139,39 +140,39 @@ export function buildNoop(input: NoopInput): TResult {
 }
 
 export function buildChanged(input: SuccessInput): TResult {
-	const { path, result, warnings, snapshotId, originalNormalized, editMeta, resultHashes } = input;
-
-	const resultLines = visLines(result);
-	const diffResult = genDiff(originalNormalized, result, 2, resultHashes);
-	const addedLines = cntDiff(diffResult.diff, "+");
-	const removedLines = cntDiff(diffResult.diff, "-");
-	const warningsBlock = warnBlock(warnings);
-	const successPrefix = `Successfully replaced in ${path}.`;
-	const text = resultLines.length === 0
-		? "File is empty. Use replace to insert content."
-		: warningsBlock
-			? `${successPrefix}${warningsBlock}`
-			: successPrefix;
-
-	const metrics = buildM({
-		classification: "applied",
-		editsAttempted: editMeta.editsAttempted,
-		noopEditsCount: editMeta.noopEditsCount,
-		warningsCount: warnings?.length ?? 0,
-		firstChangedLine: editMeta.firstChangedLine,
-		lastChangedLine: editMeta.lastChangedLine,
-		addedLines,
-		removedLines,
-	});
-
-	return {
-		content: [{ type: "text", text }],
-		details: {
-			diff: diffResult.diff,
-			firstChangedLine:
-				editMeta.firstChangedLine ?? diffResult.firstChangedLine,
-			snapshotId,
-			metrics,
-		},
-	};
+  const { path, result, warnings, snapshotId, originalNormalized, originalHashes, editMeta, resultHashes } = input;
+
+  const resultLines = visLines(result);
+  const diffResult = genDiff(originalNormalized, result, 2, resultHashes, originalHashes);
+  const addedLines = cntDiff(diffResult.diff, "+");
+  const removedLines = cntDiff(diffResult.diff, "-");
+  const warningsBlock = warnBlock(warnings);
+  const successPrefix = `Successfully replaced in ${path}.`;
+  const text = resultLines.length === 0
+    ? "File is empty. Use replace to insert content."
+    : warningsBlock
+      ? `${successPrefix}${warningsBlock}`
+      : successPrefix;
+
+  const metrics = buildM({
+    classification: "applied",
+    editsAttempted: editMeta.editsAttempted,
+    noopEditsCount: editMeta.noopEditsCount,
+    warningsCount: warnings?.length ?? 0,
+    firstChangedLine: editMeta.firstChangedLine,
+    lastChangedLine: editMeta.lastChangedLine,
+    addedLines,
+    removedLines,
+  });
+
+  return {
+    content: [{ type: "text", text }],
+    details: {
+      diff: diffResult.diff,
+      firstChangedLine:
+        editMeta.firstChangedLine ?? diffResult.firstChangedLine,
+      snapshotId,
+      metrics,
+    },
+  };
 }

package/src/replace.ts

@@ -165,10 +165,18 @@ export async function execPipeline(
 
   const result = anchorResult.content;
 
-  // Compute stable result hashes using diff-based preservation
+  // Collect hashes targeted by the edit for hash-aware diff disambiguation
+  const removedHashes = new Set<string>();
+  for (const edit of resolved) {
+    removedHashes.add(edit.hash_range_inclusive[0].hash);
+    removedHashes.add(edit.hash_range_inclusive[1].hash);
+  }
+
+  // Compute stable result hashes using hash-aware preservation
   const resultHashes = await lineHashes(result, absolutePath, {
     content: originalNormalized,
     hashes: originalHashes,
+    removedHashes,
   });
 
   // Format boundary warnings using stable result hashes
@@ -220,7 +228,7 @@ export async function compPreview(
   try {
     const normalized = normReq(request);
     assertReq(normalized);
-    const { path, originalNormalized, result, resultHashes } = await execPipeline(
+    const { path, originalNormalized, originalHashes, result, resultHashes } = await execPipeline(
       normalized,
       cwd,
       constants.R_OK,
@@ -232,7 +240,7 @@ export async function compPreview(
       };
     }
 
-    return { diff: genDiff(originalNormalized, result, 4, resultHashes).diff };
+    return { diff: genDiff(originalNormalized, result, 4, resultHashes, originalHashes).diff };
   } catch (error: unknown) {
     return { error: error instanceof Error ? error.message : String(error) };
   }
@@ -383,6 +391,7 @@ export function buildToolDef(): ToolDef {
 
         const {
           originalNormalized,
+          originalHashes,
           result,
           bom,
           originalEnding,
@@ -441,13 +450,13 @@ export function buildToolDef(): ToolDef {
         const successInput = {
           path,
           originalNormalized,
+          originalHashes,
           result,
           resultHashes,
           warnings,
           snapshotId: updatedSnapshotId,
           editMeta,
         };
-
         return buildChanged(successInput);
       });
     },