pi-hashline-edit-pro 4.5.2 → 4.5.3

package/README.md

@@ -186,7 +186,7 @@ Edge cases:
 | --- | --- |
 | `remove_from` | 4-char anchor marking the FIRST line to remove (inclusive). |
 | `remove_to` | 4-char anchor marking the LAST line to remove (inclusive). |
-| `replacement_lines` | Replacement lines, one element per line. Mirror the removed lines exactly, blank lines included: `[]` deletes the range, `[""]` is a single blank line, `["a", ""]` is a line followed by a blank line. One element is one line: a real line-break character (`\n`, `\r\n`, or `\r`) splits it and sets that line's ending; escapes decode once — `\uXXXX` is the character, `\\uXXXX` the literal text. A lone string is accepted too: it is split on newlines, and stringified array text is unwrapped. |
+| `replacement_lines` | Replacement lines, one element per line. Mirror the removed lines exactly, blank lines included: `[]` deletes the range, `[""]` is a single blank line, `["a", ""]` is a line followed by a blank line. One element is one line: a real line-break character (`\n`, `\r\n`, or `\r`) splits it and sets the line's ending; escapes decode once — `\uXXXX` is the character, `\\uXXXX` the literal text. A trailing line-break sets the ending of the element's last line instead of adding a blank line, so `["b\n"]` sets that line's ending to LF, `["b\r\n"]` to CRLF, and on a file without a final newline it adds it. A lone string is accepted too: it is split on newlines, and stringified array text is unwrapped. |
 
 Example: read showed `Hasu│old` and `arvm│old2`; to replace both:
 
@@ -208,7 +208,7 @@ Content containing a NUL byte (`U+0000`) is rejected with `[E_BAD_SHAPE]` before
 
 Every line in the removed range must match what was last shown to you. The extension records the `anchor│content` rows it serves (`read` output, `anchor_grep` output, the auto-read block after `write`, the `+anchor│` and ` anchor│` rows of post-edit diffs, the current-range rows of `[E_RANGE_STALE]` feedback, and the context rows of stale-anchor feedback) and verifies the whole range against that record before writing. A line that changed on disk since it was shown, or an anchor that is not owned in this session, refuses the edit with `[E_RANGE_STALE]` or `[E_STALE_ANCHOR]` and returns the current range with fresh anchors, so the retry needs no `read`. An owned anchor enters the served record when its row is shown (after a restart, restored ownership counts as shown), so a file with no owned anchors cannot be edited by anchor at all; call `read` first. An owned line that was never shown, for example beyond an auto-read preview's truncation cap, is refused with `[E_RANGE_STALE]` and returns the current range, so the retry still needs no `read`.
 
-An edit that produces identical content reports `No changes made` and leaves the anchors alone.
+An edit that changes neither content nor line endings reports `No changes made` and leaves the anchors alone.
 
 After a successful edit, the diff is capped at 50KB. A row over 50KB is shown as a marker that keeps the row's anchor, and only the rows shown in the capped diff are recorded as served. The same caps apply to the `insert` and `undo_last_change` diffs, to the interactive previews, and to `details.patch`.
 
@@ -220,7 +220,7 @@ After a successful edit, the diff is capped at 50KB. A row over 50KB is shown as
 | --- | --- |
 | `anchor` | 4-char anchor marking the line next to which the lines go. The anchor line is preserved. A pasted `+Hasu│x` diff row or `anchor│` prefix is stripped automatically with a warning. |
 | `direction` | `"after"` inserts below the anchor line, `"before"` above it. |
-| `lines` | Lines to insert, one element per line. `[""]` is a blank line. Never include the anchor line. One element is one line: a real line-break character (`\n`, `\r\n`, or `\r`) splits it and sets that line's ending; escapes decode once — `\uXXXX` is the character, `\\uXXXX` the literal text. A lone string is split on newlines, and stringified array text is unwrapped. |
+| `lines` | Lines to insert, one element per line. `[""]` is a blank line. Never include the anchor line. One element is one line: a real line-break character (`\n`, `\r\n`, or `\r`) splits it and sets the line's ending; escapes decode once — `\uXXXX` is the character, `\\uXXXX` the literal text. A trailing line-break sets the ending of the element's last line instead of adding a blank line, so `["b\n"]` inserts `b` with an LF ending, and on a file without a final newline it adds it. A lone string is split on newlines, and stringified array text is unwrapped. |
 
 Nothing is removed and the inserted lines are written exactly as given; the anchor line and every other line stay in place. Inserting nothing (`lines: []`) reports a noop. To seed an empty file, read it and insert after the `anchor│` empty-line row.
 
@@ -314,6 +314,8 @@ Auto-read is enabled by default. After a successful `write`, the extension reads
 
 After `replace`, `insert`, `copy`, `move`, and `undo_last_change`, the result shows the post-edit diff. Inside a same-message batch, only the batch's last call shows the combined diff, headed by a `batch N:` line; earlier calls reply `In batch N`. The `+anchor│` and ` anchor│` rows carry the current anchors, so follow-up edits can anchor on the diff directly. The `-anchor│` rows show removed lines with their old anchors, which are stale after the edit. When the context line next to a change is blank or whitespace-only, one more context line is shown in that direction, so the change stays anchored to visible content. Call `read` when you want the full file's anchors.
 
+An edit that changes only line endings has no content diff; the result still reports `applied`, and one `undo_last_change` reverts it.
+
 Auto-read keeps the same 50KB and 2000-line budget as `read`. Auto-read and Diff context live in `/hashline-config` and persist across sessions. The post-edit diff shows 1 surrounding line by default; change Diff context in `/hashline-config` (0-10, needs Auto-read) to show more or fewer.
 
 ## Auto-read all

package/index.ts

@@ -280,7 +280,8 @@ export default function (pi: ExtensionAPI): void {
     const warnings = detailWarnings.length ? `Warnings:\n${detailWarnings.join("\n")}` : extractWarnings(rendered);
     const hints = detailHints.length ? `Hints:\n${detailHints.join("\n")}` : extractHints(rendered);
     const notices = [warnings, hints].filter((part): part is string => part !== undefined).join("\n\n");
-    const noticeText = hasDiff ? (notices ? `${diff}\n\n${notices}` : diff) : notices ? `[post-edit] applied successfully; the diff is empty (whitespace-only change).\n\n${notices}` : "[post-edit] applied successfully; the diff is empty (whitespace-only change).";
+    const emptyDiffNotice = "[post-edit] applied successfully; the diff is empty (no content change: whitespace or line endings only).";
+    const noticeText = hasDiff ? (notices ? `${diff}\n\n${notices}` : diff) : notices ? `${emptyDiffNotice}\n\n${notices}` : emptyDiffNotice;
     return {
       content: [
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "4.5.2",
+  "version": "4.5.3",
   "type": "module",
   "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 4-char tokenizer-friendly anchor that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",

package/prompts/replace-guidelines.md

@@ -1,4 +1,4 @@
 - `replace`: `-anchor│` rows in a post-edit diff are dead anchors; only `+anchor│` and ` anchor│` rows are live. Check the post-edit diff before the next turn's edits on that file.
 - `replace`: same-file same-message calls batch: disjoint ranges, one undo. A call whose anchors resolve nowhere fails alone; its file's batch still commits.
-- `replace`: use `replace`/`insert`, not `sed -i` or heredocs — anchor edits are verified against what was shown and undoable.
+- `replace`: use `replace`/`insert` for structural or multi-line edits — anchored, verified, undoable.
 - `replace`: `replacement_lines`: one string per line, `[""]` is one blank line, `[]` deletes. Pasted `anchor│` prefixes are stripped. Single line: same anchor for `remove_from` and `remove_to`.

package/src/batch.ts

@@ -543,13 +543,31 @@ export async function executeBatchMember(input: BatchMemberInput): Promise<TResu
 
 function composeBatchLines(baseContent: string, pieces: BatchPiece[]): string {
   const lines = splitLines(baseContent);
+  const baseLineCount = lines.length;
   const descending = [...pieces].sort((a, b) => b.start - a.start);
   for (const piece of descending) lines.splice(piece.start - 1, piece.end - piece.start + 1, ...piece.newLines);
   let composed = lines.join("\n");
-  if (lines.length > 0 && (baseContent.endsWith("\n") || lines[lines.length - 1] === "")) composed += "\n";
+  if (lines.length > 0 && (baseContent.endsWith("\n") || lines[lines.length - 1] === "")) {
+    composed += "\n";
+  } else if (lines.length > 0) {
+    const trailing = pieces.reduce<BatchPiece | undefined>((best, piece) => (best === undefined || piece.end > best.end ? piece : best), undefined);
+    const lastEnding = trailing?.separators?.[trailing.newLines.length - 1];
+    if (trailing !== undefined && trailing.end === baseLineCount && lastEnding !== undefined) composed += "\n";
+  }
   return composed;
 }
 
+function changesEnding(piece: BatchPiece, baseSeparators: LineEnding[]): boolean {
+  if (piece.separators === undefined) return false;
+  for (let index = 0; index < piece.separators.length; index++) {
+    const ending = piece.separators[index];
+    if (ending === undefined) continue;
+    const baseIndex = piece.start - 1 + index;
+    if (baseIndex >= baseSeparators.length || baseSeparators[baseIndex] !== ending) return true;
+  }
+  return false;
+}
+
 function mergeInsertPairs(pieces: BatchPiece[]): BatchPiece[] {
   const byAnchor = new Map<number, BatchPiece[]>();
   for (const piece of pieces) {
@@ -624,11 +642,12 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
     }
   }
   const appliedPieces = runtime.pieces.filter((piece) => !piece.noop);
-  if (appliedPieces.length === 0) {
+  const candidatePieces = runtime.pieces.filter((piece) => !piece.noop || changesEnding(piece, base.separators));
+  if (candidatePieces.length === 0) {
     const snapshotId = await safeSnapId(paths.absolutePath, "noop edit");
     return combinedNoop(paths.displayPath, member, runtime, snapshotId);
   }
-  const effectivePieces = mergeInsertPairs(appliedPieces);
+  const effectivePieces = mergeInsertPairs(candidatePieces);
   const ordered = [...effectivePieces].sort((a, b) => a.start - b.start);
   for (let i = 1; i < ordered.length; i++) {
     const prev = ordered[i - 1]!;
@@ -649,11 +668,12 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
   })));
   const warnings = [...runtime.warnings];
   if (base.hadUtf8DecodeErrors) warnings.push("Non-UTF-8 bytes were shown as U+FFFD; this edit rewrote the file as UTF-8.");
+  const finalBytes = base.bom + joinSeparators(composed, resultSeparators);
+  const originalBytes = base.bom + joinSeparators(base.content, base.separators);
   try {
     await throwIfStrictInput(dedupeWarnings(warnings));
     assertNotEmpty(base.content, composed);
     assertLineLimit(composed, paths.displayPath, MAX_HASH_LINES);
-    const finalBytes = base.bom + joinSeparators(composed, resultSeparators);
     assertByteLimit(finalBytes, paths.displayPath);
   } catch (error) {
     discardBatchState(runtime);
@@ -662,7 +682,7 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
   }
   const reclaimNotice = formatAnchorReclaimNotice(takeReclaimedPaths());
   if (reclaimNotice !== undefined) warnings.push(reclaimNotice);
-  if (composed === base.content) {
+  if (finalBytes === originalBytes) {
     const snapshotId = await safeSnapId(paths.absolutePath, "noop edit");
     return combinedNoop(paths.displayPath, member, runtime, snapshotId);
   }
@@ -756,8 +776,10 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
     batchVerb(runtime),
     await getDiffContextLines(),
   );
-  changed.details.diff = `${header}\n${changed.details.diff}`;
-  changed.details.diffLineNumbers?.unshift(null);
+  if (changed.details.diff.length > 0) {
+    changed.details.diff = `${header}\n${changed.details.diff}`;
+    changed.details.diffLineNumbers?.unshift(null);
+  }
   try {
     serveRows(runtime.target, resultHashes, splitLines(composed), servedHashesFromDiff(changed.details.diff));
   } catch (error) {

package/src/commit.ts

@@ -33,7 +33,22 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
   const readReclaim = formatAnchorReclaimNotice(takeReclaimedPaths());
   if (readReclaim !== undefined) warnings.push(readReclaim);
 
-  if (pipe.result === pipe.originalNormalized) {
+  const span = pipe.spans?.[0] ?? (meta.editAnchors ? spanForEdit(pipe.originalHashes, meta.editAnchors[0], meta.editAnchors[1], pipe.result) : undefined);
+  if (span && meta.anchorCarry !== undefined) span.carry = meta.anchorCarry;
+  const resultSeparators = span
+    ? separatorsForSpans(pipe.originalSeparators, pipe.originalHashes.length, [span], pipe.result, pipe.originalEnding)
+    : undefined;
+  if (resultSeparators !== undefined && span !== undefined) {
+    applyEndingOverrides(resultSeparators, span.start, pipe.contentSeparators);
+    applyEndingOverrides(resultSeparators, span.start, meta.endingOverrides);
+  }
+  const finalFileBytes = pipe.bom + (resultSeparators !== undefined
+    ? joinSeparators(pipe.result, resultSeparators)
+    : restoreEndings(pipe.result, pipe.originalEnding));
+  const contentUnchanged = pipe.result === pipe.originalNormalized;
+  const bytesUnchanged = contentUnchanged && (span === undefined || finalFileBytes === pipe.bom + joinSeparators(pipe.originalNormalized, pipe.originalSeparators));
+
+  if (bytesUnchanged) {
     const noopSnapshotId = await safeSnapId(absolutePath, "noop edit");
     return buildNoop(
       {
@@ -52,18 +67,6 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     );
   }
 
-  const span = pipe.spans?.[0] ?? (meta.editAnchors ? spanForEdit(pipe.originalHashes, meta.editAnchors[0], meta.editAnchors[1], pipe.result) : undefined);
-  if (span && meta.anchorCarry !== undefined) span.carry = meta.anchorCarry;
-  const resultSeparators = span
-    ? separatorsForSpans(pipe.originalSeparators, pipe.originalHashes.length, [span], pipe.result, pipe.originalEnding)
-    : undefined;
-  if (resultSeparators !== undefined && span !== undefined) {
-    applyEndingOverrides(resultSeparators, span.start, pipe.contentSeparators);
-    applyEndingOverrides(resultSeparators, span.start, meta.endingOverrides);
-  }
-  const finalFileBytes = pipe.bom + (resultSeparators !== undefined
-    ? joinSeparators(pipe.result, resultSeparators)
-    : restoreEndings(pipe.result, pipe.originalEnding));
   assertByteLimit(finalFileBytes, path);
 
   if (pipe.hadUtf8DecodeErrors) {

package/src/copy-move.ts

@@ -544,6 +544,7 @@ async function executeCrossFile(
       accessMode: constants.R_OK | constants.W_OK,
       signal,
       preloadedNorm: prepared.destinationPreload,
+      endingOverrides: prepared.endingOverrides,
     });
     if (kind === "copy") {
       return commitEdit(destinationPipe, {
@@ -610,6 +611,7 @@ export async function transferPreview(kind: TransferKind, request: unknown, cwd:
         noPersist: true,
         preloadedNorm: preload,
         served: plan.servedOverride,
+        endingOverrides: plan.endingOverrides,
         signal,
       });
       return previewFromPipe(pipe);
@@ -619,6 +621,7 @@ export async function transferPreview(kind: TransferKind, request: unknown, cwd:
       accessMode: constants.R_OK,
       noPersist: true,
       preloadedNorm: prepared.destinationPreload,
+      endingOverrides: prepared.endingOverrides,
       signal,
     });
     if (kind === "copy") return previewFromPipe(destinationPipe);
@@ -764,6 +767,7 @@ export function buildTransferToolDef(kind: TransferKind, flags: EditToolFlags =
             signal,
             preloadedNorm: preload,
             served: plan.servedOverride,
+            endingOverrides: plan.endingOverrides,
           });
           return commitEdit(pipe, {
             path: pipe.path,

package/src/hashline/apply.ts

@@ -68,12 +68,12 @@ function resToSpan(
   const startLine = edit.hash_bounds[0].line;
   const endLine = edit.hash_bounds[1].line;
   const originalLines = fileLines.slice(startLine - 1, endLine);
-  if (
+  const contentUnchanged =
     originalLines.length === edit.content_lines.length &&
     originalLines.every(
       (line, lineIndex) => line === edit.content_lines[lineIndex],
-    )
-  ) {
+    );
+  if (contentUnchanged && edit.content_separators === undefined) {
     return {
       kind: "noop",
       loc: edit.hash_bounds[0].hash,
@@ -82,7 +82,9 @@ function resToSpan(
   }
 
   if (edit.content_lines.length > 0) {
-    const lastReplacementLine = edit.content_lines[edit.content_lines.length - 1]!;
+    const lastIndex = edit.content_lines.length - 1;
+    const lastReplacementLine = edit.content_lines[lastIndex]!;
+    const lastEnding = edit.content_separators?.[lastIndex];
     const endsWithBlank = lastReplacementLine.length === 0;
     const endsAtEofWithoutNewline =
       endLine === fileLines.length && !content.endsWith("\n");
@@ -92,7 +94,7 @@ function resToSpan(
       start: lineStarts[startLine - 1]!,
       end: lineStarts[endLine - 1]! + fileLines[endLine - 1]!.length,
       replacement:
-        endsAtEofWithoutNewline && endsWithBlank
+        endsAtEofWithoutNewline && (endsWithBlank || lastEnding !== undefined)
           ? `${replacement}\n`
           : replacement,
     };

package/src/hashline/parse.ts

@@ -81,10 +81,14 @@ export function parseTextWithSeparators(edit: string[]): ParsedText {
 	}
 	const lines: string[] = [];
 	const separators: (LineEnding | undefined)[] = [];
-	for (const line of edit) {
-		const parsed = splitWithEndings(unwrapJsonEnvelope(line));
-		lines.push(...parsed.lines);
-		separators.push(...parsed.endings);
+	for (const element of edit) {
+		const text = unwrapJsonEnvelope(element);
+		const parsed = splitWithEndings(text);
+		const lineCount = text.endsWith("\n") || text.endsWith("\r") ? parsed.lines.length - 1 : parsed.lines.length;
+		for (let index = 0; index < lineCount; index++) {
+			lines.push(parsed.lines[index]!);
+			separators.push(parsed.endings[index]!);
+		}
 	}
 	return { lines, separators };
 }

package/src/hashline/resolve.ts

@@ -18,6 +18,7 @@ export type HEdit = {
 export type RHEdit = {
   content_lines: string[];
   hash_bounds: [RAnchor, RAnchor];
+  content_separators?: (LineEnding | undefined)[];
 };
 
 interface HMismatch {
@@ -288,6 +289,7 @@ export function valEdit(
 		resolved: {
 			content_lines: edit.content_lines,
 			hash_bounds: [startResolved, endResolved],
+			...(edit.content_separators !== undefined ? { content_separators: edit.content_separators } : {}),
 		},
 		mismatches,
 	};

package/src/insert.ts

@@ -125,13 +125,14 @@ export async function insertPreview(request: unknown, cwd: string, signal?: Abor
       allocation: "shadow",
       signal,
     });
-    const { editParams, anchorLine } = buildInsertEdit(normalized, preload, ref, targetPath);
+    const { editParams, anchorLine, contentSeparators } = buildInsertEdit(normalized, preload, ref, targetPath);
     const pipe = await execPipeline(targetPath, editParams, cwd, {
       accessMode: constants.R_OK,
       noPersist: true,
       preloadedNorm: preload,
       signal,
       stripWarning: insertStripWarning(anchorLine, normalized.direction),
+      endingOverrides: contentSeparators,
     });
     return previewFromPipe(pipe);
   } catch (error: unknown) {
@@ -253,6 +254,7 @@ export function buildInsertToolDef(flags: EditToolFlags = DEFAULT_EDIT_FLAGS): I
             signal,
             preloadedNorm: preload,
             stripWarning: insertStripWarning(anchorLine, req.direction),
+            endingOverrides: contentSeparators,
           });
           return commitEdit(pipe, {
             path: pipe.path,

package/src/replace.ts

@@ -83,6 +83,7 @@ export interface ExecPipelineOptions {
   served?: ReadonlyMap<string, string>;
   allowEmpty?: boolean;
   stripWarning?: StripWarningLocation;
+  endingOverrides?: (LineEnding | undefined)[];
 }
 
 export function hashSpan(hashes: string[], from: string, to: string): [number, number] | undefined {
@@ -134,6 +135,17 @@ export function buildReplaceHEdit(params: ReqParams): { edit: HEdit; warnings: s
   return { edit, warnings: editWarnings };
 }
 
+function withEndingOverrides(edit: HEdit, overrides: (LineEnding | undefined)[] | undefined): HEdit {
+  if (overrides === undefined) return edit;
+  const length = Math.max(edit.content_separators?.length ?? 0, overrides.length);
+  const separators: (LineEnding | undefined)[] = new Array(length);
+  for (let index = 0; index < length; index++) {
+    separators[index] = overrides[index] ?? edit.content_separators?.[index];
+  }
+  if (separators.every((ending) => ending === undefined)) return edit;
+  return { ...edit, content_separators: separators };
+}
+
 export async function execPipeline(
   targetPath: string,
   params: ReqParams,
@@ -142,6 +154,7 @@ export async function execPipeline(
 ): Promise<PipelineResult> {
 
   const { edit, warnings: editWarnings } = buildReplaceHEdit(params);
+  const anchoredEdit = withEndingOverrides(edit, options?.endingOverrides);
   const hashStore = options?.store ?? await loadHashStore();
   const preResolvedPath = await resolveTarget(toCwd(targetPath, cwd));
   const served = options?.served ?? servedForPath(preResolvedPath);
@@ -154,7 +167,7 @@ export async function execPipeline(
   try {
     anchorResult = applyEdit(
       originalNormalized,
-      edit,
+      anchoredEdit,
       options?.signal,
       originalHashes,
       displayPath,
@@ -202,12 +215,15 @@ export async function execPipeline(
     totalRemovedLines,
     identity,
     ...(pipeSpans ? { spans: pipeSpans } : {}),
-    ...(edit.content_separators !== undefined ? { contentSeparators: edit.content_separators } : {}),
+    ...(anchoredEdit.content_separators !== undefined ? { contentSeparators: anchoredEdit.content_separators } : {}),
   };
 }
 
 export function previewFromPipe(pipe: PipelineResult): RPreview {
   if (pipe.originalNormalized === pipe.result) {
+    if (pipe.contentSeparators !== undefined) {
+      return { diff: "", path: pipe.path };
+    }
     return {
       error: `No changes made to ${pipe.path}. The edit produced identical content.`,
       path: pipe.path,