critique 0.1.129 → 0.1.134

package/dist/balance-delimiters.d.ts

@@ -13,9 +13,13 @@ export declare function countDelimiter(code: string, delimiter: string): number;
  * Pass 1 (tokenize): for each hunk, extract content lines and count
  * delimiter occurrences.
  *
- * Pass 2 (fix): if a hunk has an odd count for any delimiter, prepend
- * that delimiter to the first content line so tree-sitter sees balanced
- * pairs. No header adjustment needed since no new lines are added.
+ * Pass 2 (repair): if a hunk has an odd count for any symmetric delimiter,
+ * classify the unmatched boundary token as a likely opener or closer and
+ * escape that token in place.
+ *
+ * Pass 3 (hunk isolation): if a hunk leaves an asymmetric delimiter open,
+ * append its closing token to the last content line so the next hunk starts
+ * from a clean parser state.
  */
 export declare function balanceDelimiters(rawDiff: string, filetype?: string): string;
 //# sourceMappingURL=balance-delimiters.d.ts.map

package/dist/balance-delimiters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"balance-delimiters.d.ts","sourceRoot":"","sources":["../src/balance-delimiters.ts"],"names":[],"mappings":"AAqCA;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CActE;AAOD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CA4D5E"}
+{"version":3,"file":"balance-delimiters.d.ts","sourceRoot":"","sources":["../src/balance-delimiters.ts"],"names":[],"mappings":"AA4DA;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CActE;AAmPD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAqE5E"}

package/dist/balance-delimiters.js

@@ -1,37 +1,50 @@
 // Delimiter balancing for syntax highlighting in diff hunks.
 //
-// When a diff hunk starts inside a paired delimiter (template literal,
-// triple-quoted string, fenced code block, etc.), tree-sitter sees an
-// odd number of that delimiter and misparses everything after the first
-// occurrence.
+// When a diff hunk starts or ends inside a paired delimiter (template
+// literal, triple-quoted string, fenced code block, etc.), tree-sitter can
+// misparse everything after the unmatched token.
 //
-// Two-pass fix:
+// Boundary repair strategy:
 //   1. Tokenizer: count delimiter occurrences in each hunk's content,
 //      skipping escaped characters.
-//   2. Fix: if a hunk has an odd count, prepend a balancing delimiter to
-//      the first content line so tree-sitter sees balanced pairs.
+//   2. Repair symmetric delimiters by escaping the unmatched boundary token.
+//   3. Repair asymmetric delimiters by appending the closing token to the
+//      last content line in the hunk so later hunks do not inherit state.
 //
-// Why no string/comment state tracking: the tokenizer processes partial
-// code (diff hunks) that may start mid-string. Tracking quote states
-// causes false positives when template text contains apostrophes
-// (`it's`) or quotes (`class="foo"`). Tracking comment states breaks
-// on `://` in URL templates. The \-escape handler already covers
-// escaped delimiters, and unescaped delimiters in "wrong" contexts
-// (strings, comments) are rare enough that the tradeoff is worth it.
+// Why this is safer than prepending a synthetic opener: prepending fixes hunks
+// that begin inside a string, but it corrupts hunks that end inside an open
+// string/fence/docstring. Escaping the actual unmatched token keeps the repair
+// local and avoids duplicating delimiters like ``` -> ``````.
+const cStyleBlockCommentRule = {
+    token: "/*",
+    closeToken: "*/",
+};
+const htmlCommentRule = {
+    token: "<!--",
+    closeToken: "-->",
+};
 /**
  * Delimiters to balance per language filetype.
  *
- * Each entry maps a filetype (from detectFiletype) to the list of
- * delimiters that come in open/close pairs and can span lines.
+ * Each entry maps a filetype (from detectFiletype) to the list of delimiters
+ * that come in open/close pairs and can span lines.
  */
 const LANGUAGE_DELIMITERS = {
-    typescript: ["`"],
-    python: ['"""', "'''"],
-    markdown: ["```"],
-    go: ["`"],
-    scala: ['"""'],
-    swift: ['"""'],
-    julia: ['"""'],
+    typescript: [{ token: "`" }, cStyleBlockCommentRule],
+    python: [{ token: '"""' }, { token: "'''" }],
+    markdown: [{ token: "```" }],
+    go: [{ token: "`" }, cStyleBlockCommentRule],
+    rust: [cStyleBlockCommentRule],
+    cpp: [cStyleBlockCommentRule],
+    csharp: [cStyleBlockCommentRule],
+    c: [cStyleBlockCommentRule],
+    java: [cStyleBlockCommentRule],
+    php: [cStyleBlockCommentRule],
+    scala: [{ token: '"""' }, cStyleBlockCommentRule],
+    html: [htmlCommentRule],
+    css: [cStyleBlockCommentRule],
+    swift: [{ token: '"""' }, cStyleBlockCommentRule],
+    julia: [{ token: '"""' }],
 };
 /**
  * Count unescaped occurrences of a delimiter in a code string.
@@ -49,11 +62,183 @@ export function countDelimiter(code, delimiter) {
         }
         else if (code.startsWith(delimiter, i)) {
             count++;
-            i += len - 1; // -1 because the loop increments
+            i += len - 1;
         }
     }
     return count;
 }
+function isDiffContentLine(line) {
+    return line[0] === " " || line[0] === "+" || line[0] === "-";
+}
+function getContentLines(lines) {
+    return lines.flatMap((line, hunkLineIndex) => isDiffContentLine(line)
+        ? [{ hunkLineIndex, content: line.slice(1) }]
+        : []);
+}
+function findDelimiterOccurrences(contentLines, delimiter) {
+    const occurrences = [];
+    for (const [contentLineIndex, line] of contentLines.entries()) {
+        const content = line.content;
+        const len = delimiter.length;
+        for (let column = 0; column < content.length; column++) {
+            if (content[column] === "\\") {
+                column++;
+                continue;
+            }
+            if (!content.startsWith(delimiter, column)) {
+                continue;
+            }
+            occurrences.push({
+                contentLineIndex,
+                hunkLineIndex: line.hunkLineIndex,
+                column,
+            });
+            column += len - 1;
+        }
+    }
+    return occurrences;
+}
+function findAnyDelimiterOccurrences(contentLines, delimiters) {
+    const ordered = [...delimiters].sort((a, b) => b.length - a.length);
+    const occurrences = [];
+    for (const [contentLineIndex, line] of contentLines.entries()) {
+        const content = line.content;
+        for (let column = 0; column < content.length; column++) {
+            if (content[column] === "\\") {
+                column++;
+                continue;
+            }
+            const matched = ordered.find((delimiter) => content.startsWith(delimiter, column));
+            if (!matched) {
+                continue;
+            }
+            occurrences.push({
+                contentLineIndex,
+                hunkLineIndex: line.hunkLineIndex,
+                column,
+            });
+            column += matched.length - 1;
+        }
+    }
+    return occurrences;
+}
+function getPreviousNonWhitespaceChar(content, column) {
+    for (let i = column - 1; i >= 0; i--) {
+        const char = content[i];
+        if (char && !/\s/.test(char)) {
+            return char;
+        }
+    }
+    return undefined;
+}
+function getNextNonWhitespaceChar(content, column) {
+    for (let i = column; i < content.length; i++) {
+        const char = content[i];
+        if (char && !/\s/.test(char)) {
+            return char;
+        }
+    }
+    return undefined;
+}
+function hasNonEmptyContentBefore(contentLines, contentLineIndex) {
+    return contentLines.slice(0, contentLineIndex).some((line) => line.content.trim() !== "");
+}
+function hasNonEmptyContentAfter(contentLines, contentLineIndex) {
+    return contentLines.slice(contentLineIndex + 1).some((line) => line.content.trim() !== "");
+}
+function classifyOccurrence(contentLines, occurrence, token) {
+    const content = contentLines[occurrence.contentLineIndex]?.content;
+    if (content === undefined) {
+        return "unknown";
+    }
+    const before = getPreviousNonWhitespaceChar(content, occurrence.column);
+    const after = getNextNonWhitespaceChar(content, occurrence.column + token.length);
+    const trimmed = content.trim();
+    const hasBeforeLines = hasNonEmptyContentBefore(contentLines, occurrence.contentLineIndex);
+    const hasAfterLines = hasNonEmptyContentAfter(contentLines, occurrence.contentLineIndex);
+    if (token.length > 1) {
+        if (trimmed === token) {
+            if (hasBeforeLines)
+                return "close";
+            if (hasAfterLines)
+                return "open";
+            return "unknown";
+        }
+        if (trimmed.startsWith(token)) {
+            if (hasBeforeLines && (!after || /[.\])};:,]/.test(after))) {
+                return "close";
+            }
+            if (after) {
+                return "open";
+            }
+        }
+        if (trimmed.endsWith(token)) {
+            return "close";
+        }
+        return "unknown";
+    }
+    if (!before && after) {
+        return "open";
+    }
+    if (before && !after) {
+        return "close";
+    }
+    if (after && /[$A-Za-z0-9_{[(]/.test(after)) {
+        return "open";
+    }
+    if (before && after && /[)\]};:.,]/.test(after)) {
+        return "close";
+    }
+    return "unknown";
+}
+function escapeDelimiterAt(lines, hunkLineIndex, column) {
+    return lines.map((line, index) => {
+        if (index !== hunkLineIndex || !isDiffContentLine(line)) {
+            return line;
+        }
+        const prefix = line[0] ?? "";
+        const content = line.slice(1);
+        return prefix + content.slice(0, column) + "\\" + content.slice(column);
+    });
+}
+function getRuleOpenTokens(rule) {
+    return rule.openTokens ?? [rule.token];
+}
+function getRuleCloseToken(rule) {
+    return rule.closeToken ?? rule.token;
+}
+function isSymmetricRule(rule) {
+    const openTokens = getRuleOpenTokens(rule);
+    const closeToken = getRuleCloseToken(rule);
+    return openTokens.length === 1 && openTokens[0] === closeToken;
+}
+function getUnclosedTokenCount(lines, rule) {
+    const contentLines = getContentLines(lines);
+    const openTokens = getRuleOpenTokens(rule);
+    const closeToken = getRuleCloseToken(rule);
+    if (isSymmetricRule(rule)) {
+        return 0;
+    }
+    const openCount = findAnyDelimiterOccurrences(contentLines, openTokens).length;
+    const closeCount = findDelimiterOccurrences(contentLines, closeToken).length;
+    return Math.max(0, openCount - closeCount);
+}
+function appendClosingTokensToLastContentLine(lines, closeToken, count) {
+    if (count <= 0) {
+        return [...lines];
+    }
+    const lastContentLineIndex = [...lines].findLastIndex(isDiffContentLine);
+    if (lastContentLineIndex === -1) {
+        return [...lines];
+    }
+    const closingSuffix = Array.from({ length: count }, () => closeToken).join(" ");
+    return lines.map((line, index) => {
+        if (index !== lastContentLineIndex || !isDiffContentLine(line)) {
+            return line;
+        }
+        return `${line} ${closingSuffix}`;
+    });
+}
 /**
  * Balance paired delimiters in a unified diff patch for correct syntax
  * highlighting.
@@ -61,20 +246,23 @@ export function countDelimiter(code, delimiter) {
  * Pass 1 (tokenize): for each hunk, extract content lines and count
  * delimiter occurrences.
  *
- * Pass 2 (fix): if a hunk has an odd count for any delimiter, prepend
- * that delimiter to the first content line so tree-sitter sees balanced
- * pairs. No header adjustment needed since no new lines are added.
+ * Pass 2 (repair): if a hunk has an odd count for any symmetric delimiter,
+ * classify the unmatched boundary token as a likely opener or closer and
+ * escape that token in place.
+ *
+ * Pass 3 (hunk isolation): if a hunk leaves an asymmetric delimiter open,
+ * append its closing token to the last content line so the next hunk starts
+ * from a clean parser state.
  */
 export function balanceDelimiters(rawDiff, filetype) {
     if (!filetype)
         return rawDiff;
-    const delimiters = LANGUAGE_DELIMITERS[filetype];
-    if (!delimiters)
+    const rules = LANGUAGE_DELIMITERS[filetype];
+    if (!rules)
         return rawDiff;
     const lines = rawDiff.split("\n");
     const fileHeader = [];
     const hunks = [];
-    // Split into file header + hunks
     for (const line of lines) {
         if (line.startsWith("@@")) {
             hunks.push({ header: line, lines: [] });
@@ -88,39 +276,42 @@ export function balanceDelimiters(rawDiff, filetype) {
     }
     if (hunks.length === 0)
         return rawDiff;
-    // Pass 2: check each hunk and fix if needed
     const result = [...fileHeader];
     for (const hunk of hunks) {
-        // Extract content text from diff lines (strip the +/-/space prefix)
-        const content = hunk.lines
-            .filter(l => l[0] === " " || l[0] === "+" || l[0] === "-")
-            .map(l => l.slice(1))
-            .join("\n");
-        // Find the first delimiter with an odd count
-        let unbalanced;
-        for (const delim of delimiters) {
-            if (countDelimiter(content, delim) % 2 !== 0) {
-                unbalanced = delim;
+        const contentLines = getContentLines(hunk.lines);
+        let repairedLines = hunk.lines;
+        for (const rule of rules) {
+            if (!isSymmetricRule(rule)) {
+                continue;
+            }
+            const occurrences = findDelimiterOccurrences(contentLines, rule.token);
+            if (occurrences.length % 2 === 0) {
+                continue;
+            }
+            const first = occurrences[0];
+            const last = occurrences[occurrences.length - 1];
+            if (!first || !last) {
+                continue;
+            }
+            const firstBoundary = classifyOccurrence(contentLines, first, rule.token);
+            const lastBoundary = classifyOccurrence(contentLines, last, rule.token);
+            if (firstBoundary === "close") {
+                repairedLines = escapeDelimiterAt(repairedLines, first.hunkLineIndex, first.column);
                 break;
             }
-        }
-        result.push(hunk.header);
-        if (unbalanced) {
-            // Prepend the balancing delimiter to the first content line
-            let fixed = false;
-            for (const line of hunk.lines) {
-                if (!fixed && (line[0] === " " || line[0] === "+" || line[0] === "-")) {
-                    result.push(line[0] + unbalanced + line.slice(1));
-                    fixed = true;
-                }
-                else {
-                    result.push(line);
-                }
+            if (lastBoundary === "open") {
+                repairedLines = escapeDelimiterAt(repairedLines, last.hunkLineIndex, last.column);
+                break;
             }
         }
-        else {
-            result.push(...hunk.lines);
+        for (const rule of rules) {
+            const unclosedCount = getUnclosedTokenCount(repairedLines, rule);
+            if (unclosedCount > 0) {
+                repairedLines = appendClosingTokensToLastContentLine(repairedLines, getRuleCloseToken(rule), unclosedCount);
+            }
         }
+        result.push(hunk.header);
+        result.push(...repairedLines);
     }
     return result.join("\n");
 }