@cruxy/cli 0.27.0 → 0.28.0

package/dist/tools/file/apply-patch.js

@@ -2,7 +2,7 @@ import { promises as fs } from "node:fs";
 import path from "node:path";
 import { z } from "zod";
 import { resolveToolPath } from "./paths.js";
-import { countOccurrences } from "./edit-file.js";
+import { applyEol, detectEol, findMatch, tierLabel } from "./match.js";
 /** How many leading lines of a created file the approval preview shows. */
 const PREVIEW_LINES = 20;
 const HunkSchema = z.object({
@@ -143,25 +143,29 @@ async function planOp(i, op, abs, ctx) {
         }
         return { ok: false, error: opError(i, op, err.message) };
     }
+    // Detect the file's line ending once, from the original bytes, so every hunk
+    // re-encodes newStr to the same convention as content mutates across hunks.
+    const fileEol = detectEol(content);
     for (let h = 0; h < op.hunks.length; h++) {
         const { oldStr, newStr } = op.hunks[h];
-        const matches = countOccurrences(content, oldStr);
-        if (matches === 0) {
+        const match = findMatch(content, oldStr);
+        if (match.kind === "none") {
             return {
                 ok: false,
                 error: opError(i, op, `hunk ${h + 1}: oldStr not found`),
             };
         }
-        if (matches > 1) {
+        if (match.kind === "ambiguous") {
             return {
                 ok: false,
-                error: opError(i, op, `hunk ${h + 1}: oldStr not unique (${matches} matches)`),
+                error: opError(i, op, `hunk ${h + 1}: oldStr not unique (${match.count} matches${tierLabel(match.tier)})`),
             };
         }
-        // Replace by index so `$` patterns in newStr aren't interpreted.
-        const idx = content.indexOf(oldStr);
+        // Splice by offset so `$` patterns in newStr aren't interpreted.
         content =
-            content.slice(0, idx) + newStr + content.slice(idx + oldStr.length);
+            content.slice(0, match.start) +
+                applyEol(newStr, fileEol) +
+                content.slice(match.end);
     }
     return {
         ok: true,

package/dist/tools/file/edit-file.d.ts

@@ -1,7 +1,5 @@
 import { z } from "zod";
 import type { Tool } from "../types.js";
-/** Count non-overlapping exact occurrences of `needle` in `haystack`. */
-export declare function countOccurrences(haystack: string, needle: string): number;
 /**
  * Replace one exact, unique occurrence of `old_str` with `new_str` in a file.
  * The uniqueness requirement is checked before approval so the model can fix an

package/dist/tools/file/edit-file.js

@@ -1,16 +1,7 @@
 import { promises as fs } from "node:fs";
 import { z } from "zod";
 import { resolveToolPath } from "./paths.js";
-/** Count non-overlapping exact occurrences of `needle` in `haystack`. */
-export function countOccurrences(haystack, needle) {
-    let count = 0;
-    let i = haystack.indexOf(needle);
-    while (i !== -1) {
-        count++;
-        i = haystack.indexOf(needle, i + needle.length);
-    }
-    return count;
-}
+import { applyEol, detectEol, findMatch, tierLabel } from "./match.js";
 /**
  * Replace one exact, unique occurrence of `old_str` with `new_str` in a file.
  * The uniqueness requirement is checked before approval so the model can fix an
@@ -47,14 +38,14 @@ export const editFileTool = {
             }
             return { ok: false, error: err.message };
         }
-        const matches = countOccurrences(content, input.old_str);
-        if (matches === 0) {
+        const match = findMatch(content, input.old_str);
+        if (match.kind === "none") {
             return { ok: false, error: `old_str not found in ${input.path}` };
         }
-        if (matches > 1) {
+        if (match.kind === "ambiguous") {
             return {
                 ok: false,
-                error: `old_str not unique (${matches} matches); add surrounding context to disambiguate`,
+                error: `old_str not unique (${match.count} matches${tierLabel(match.tier)}); add surrounding context to disambiguate`,
             };
         }
         const decision = await ctx.requestApproval({
@@ -68,11 +59,11 @@ export const editFileTool = {
                 error: decision.feedback ?? `edit to ${input.path} denied`,
             };
         }
-        // Replace the single occurrence by index to avoid `$`-pattern interpretation.
-        const idx = content.indexOf(input.old_str);
-        const updated = content.slice(0, idx) +
-            input.new_str +
-            content.slice(idx + input.old_str.length);
+        // Splice the matched span by offset (avoids `$`-pattern interpretation) and
+        // re-encode new_str to the file's line ending so a CRLF file stays CRLF.
+        const updated = content.slice(0, match.start) +
+            applyEol(input.new_str, detectEol(content)) +
+            content.slice(match.end);
         try {
             await fs.writeFile(abs, updated, "utf8");
             return { ok: true, output: `edited ${input.path}` };

package/dist/tools/file/match.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Locating `old_str` inside a file for edit_file / apply_patch.
+ *
+ * Models emit `\n` line endings, but a file on disk may be `\r\n` (Windows
+ * checkouts/editors) — a byte-exact `indexOf` then never matches and the model
+ * can't replace existing code. We match in ordered tiers, tightest first, and
+ * stop at the first tier that finds anything:
+ *
+ *   0. exact        — raw bytes; every currently-working edit takes this path
+ *   1. eol          — CRLF and lone CR treated as LF (comparison only)
+ *   2. eol+trailws  — tier 1, plus trailing whitespace ignored per line
+ *
+ * Looser tiers compare against a normalized copy but return offsets into the
+ * ORIGINAL string, so the splice preserves every unmatched byte verbatim (the
+ * file is never wholesale re-encoded). Ambiguity is never resolved by guessing:
+ * more than one match at a tier is a hard error, and we do not fall through to a
+ * looser tier (looser can only be more ambiguous, never less).
+ */
+export type Tier = "exact" | "eol" | "eol+trailws";
+export type MatchResult = {
+    kind: "found";
+    start: number;
+    end: number;
+} | {
+    kind: "ambiguous";
+    count: number;
+    tier: Tier;
+} | {
+    kind: "none";
+};
+/**
+ * Find the single occurrence of `oldStr` in `content`, tolerating line-ending
+ * and trailing-whitespace differences. Returns original-string byte offsets on
+ * a unique match, `ambiguous` if the tightest matching tier had >1 hit, or
+ * `none` if no tier matched.
+ */
+export declare function findMatch(content: string, oldStr: string): MatchResult;
+/** The file's line ending: CRLF if the first newline is `\r\n`, else LF. */
+export declare function detectEol(content: string): "\r\n" | "\n";
+/** Re-encode `text`'s line endings to `eol` so an edit matches the file. */
+export declare function applyEol(text: string, eol: "\r\n" | "\n"): string;
+/** Human phrase for the tier named in an ambiguity error. */
+export declare function tierLabel(tier: Tier): string;

package/dist/tools/file/match.js

@@ -0,0 +1,127 @@
+/**
+ * Locating `old_str` inside a file for edit_file / apply_patch.
+ *
+ * Models emit `\n` line endings, but a file on disk may be `\r\n` (Windows
+ * checkouts/editors) — a byte-exact `indexOf` then never matches and the model
+ * can't replace existing code. We match in ordered tiers, tightest first, and
+ * stop at the first tier that finds anything:
+ *
+ *   0. exact        — raw bytes; every currently-working edit takes this path
+ *   1. eol          — CRLF and lone CR treated as LF (comparison only)
+ *   2. eol+trailws  — tier 1, plus trailing whitespace ignored per line
+ *
+ * Looser tiers compare against a normalized copy but return offsets into the
+ * ORIGINAL string, so the splice preserves every unmatched byte verbatim (the
+ * file is never wholesale re-encoded). Ambiguity is never resolved by guessing:
+ * more than one match at a tier is a hard error, and we do not fall through to a
+ * looser tier (looser can only be more ambiguous, never less).
+ */
+const TIERS = ["exact", "eol", "eol+trailws"];
+/**
+ * Find the single occurrence of `oldStr` in `content`, tolerating line-ending
+ * and trailing-whitespace differences. Returns original-string byte offsets on
+ * a unique match, `ambiguous` if the tightest matching tier had >1 hit, or
+ * `none` if no tier matched.
+ */
+export function findMatch(content, oldStr) {
+    for (const tier of TIERS) {
+        const occ = occurrences(content, oldStr, tier);
+        if (occ.length === 1) {
+            return { kind: "found", start: occ[0].start, end: occ[0].end };
+        }
+        if (occ.length > 1) {
+            return { kind: "ambiguous", count: occ.length, tier };
+        }
+        // 0 matches → try the next, looser tier.
+    }
+    return { kind: "none" };
+}
+/** Non-overlapping occurrences of `oldStr` under `tier`, as original offsets. */
+function occurrences(content, oldStr, tier) {
+    const out = [];
+    if (tier === "exact") {
+        let i = content.indexOf(oldStr);
+        while (i !== -1) {
+            out.push({ start: i, end: i + oldStr.length });
+            i = content.indexOf(oldStr, i + oldStr.length);
+        }
+        return out;
+    }
+    const { norm, map } = normalize(content, tier);
+    const { norm: needle } = normalize(oldStr, tier);
+    // An all-whitespace old_str can normalize to empty under eol+trailws; refuse
+    // to "match everywhere" rather than delete at an arbitrary point.
+    if (needle.length === 0)
+        return out;
+    let i = norm.indexOf(needle);
+    while (i !== -1) {
+        out.push({ start: map[i], end: map[i + needle.length] });
+        i = norm.indexOf(needle, i + needle.length);
+    }
+    return out;
+}
+/**
+ * Build a normalized view of `s` plus `map`, where `map[k]` is the original
+ * offset of the k-th normalized char and `map[norm.length]` is a sentinel
+ * (`s.length`). This lets a match found in normalized space splice back into
+ * the original bytes exactly.
+ */
+function normalize(s, tier) {
+    const stripTrail = tier === "eol+trailws";
+    let norm = "";
+    const map = [];
+    // Whitespace whose trailing-vs-not status isn't known yet: flushed when real
+    // content follows on the line, dropped when a newline / EOF follows.
+    const pending = [];
+    const emit = (ch, off) => {
+        norm += ch;
+        map.push(off);
+    };
+    const flushPending = () => {
+        for (const p of pending)
+            emit(p.ch, p.off);
+        pending.length = 0;
+    };
+    let i = 0;
+    while (i < s.length) {
+        const c = s[i];
+        if (c === "\r" || c === "\n") {
+            pending.length = 0; // any pending whitespace was trailing → drop it
+            emit("\n", i);
+            i += c === "\r" && s[i + 1] === "\n" ? 2 : 1;
+            continue;
+        }
+        if (stripTrail && (c === " " || c === "\t")) {
+            pending.push({ ch: c, off: i });
+            i += 1;
+            continue;
+        }
+        flushPending();
+        emit(c, i);
+        i += 1;
+    }
+    // Trailing whitespace at end-of-string (in `pending`) is intentionally dropped.
+    map.push(s.length);
+    return { norm, map };
+}
+/** The file's line ending: CRLF if the first newline is `\r\n`, else LF. */
+export function detectEol(content) {
+    const i = content.indexOf("\n");
+    return i > 0 && content[i - 1] === "\r" ? "\r\n" : "\n";
+}
+/** Re-encode `text`'s line endings to `eol` so an edit matches the file. */
+export function applyEol(text, eol) {
+    const lf = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    return eol === "\r\n" ? lf.replace(/\n/g, "\r\n") : lf;
+}
+/** Human phrase for the tier named in an ambiguity error. */
+export function tierLabel(tier) {
+    switch (tier) {
+        case "exact":
+            return "";
+        case "eol":
+            return " after end-of-line normalization";
+        case "eol+trailws":
+            return " after end-of-line + trailing-whitespace normalization";
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cruxy/cli",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "description": "an agentic coding CLI",
   "type": "module",
   "bin": {