critique 0.1.129 → 0.1.135

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":"AAmEA;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CActE;AAwbD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CA4E5E"}

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: "```", classifyFence: classifyMarkdownFence }],
+    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,354 @@ 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);
+    });
+}
+// ---------------------------------------------------------------------------
+// Contextual fence classification and repair (markdown code fences)
+// ---------------------------------------------------------------------------
+/**
+ * Classify a ``` occurrence as a markdown fence opener, closer, or not a fence.
+ *
+ * Returns null if the occurrence is not a valid block-level fence (e.g. inline
+ * triple-backtick in prose, or indented more than 3 spaces).
+ * Returns "open" if followed by an info string (language tag).
+ * Returns "close" if nothing follows the backtick run (only whitespace).
+ */
+function classifyMarkdownFence(content, column) {
+    // Must be at start of line with at most 3 spaces of indentation
+    const beforeFence = content.slice(0, column);
+    if (beforeFence.length > 3 || /\S/.test(beforeFence))
+        return null;
+    // Count consecutive backticks (support 4+ backtick fences per CommonMark)
+    let fenceLen = 0;
+    for (let i = column; i < content.length && content[i] === "`"; i++)
+        fenceLen++;
+    if (fenceLen < 3)
+        return null;
+    // What comes after the backtick run?
+    const afterFence = content.slice(column + fenceLen).trim();
+    // Closing fence: nothing after backticks (only whitespace)
+    if (!afterFence)
+        return "close";
+    // Opening fence: has info string (language tag)
+    // Info string must not contain backticks (CommonMark spec)
+    if (!afterFence.includes("`"))
+        return "open";
+    return null;
+}
+/**
+ * Simulate a sequential walk through classified fences to detect boundary
+ * artifacts. Markdown code fences don't nest, so depth toggles between 0
+ * (outside) and 1 (inside).
+ *
+ * - "open" (has info string) always pushes depth to 1.
+ * - "close" (bare fence) decrements if inside, or acts as a bare opener
+ *   if already outside (a code block without a language tag).
+ *
+ * Conflicts are counted when a must-open fires while already inside (depth
+ * was already 1) or when other impossible transitions occur.
+ */
+function walkFences(fences, startDepth) {
+    let depth = startDepth;
+    let conflicts = 0;
+    for (const fence of fences) {
+        if (fence.kind === "open") {
+            if (depth > 0)
+                conflicts++;
+            depth = 1;
+        }
+        else {
+            // "close" (bare fence): close if inside, otherwise bare opener
+            if (depth > 0) {
+                depth = 0;
+            }
+            else {
+                depth = 1;
+            }
+        }
+    }
+    return { startDepth, endDepth: depth, conflicts };
+}
+/**
+ * Repair context-dependent fences (like markdown ```) using sequential
+ * open/close pairing instead of simple odd/even counting.
+ *
+ * Tries two starting states (outside vs inside a code block), picks the
+ * walk with fewer conflicts, and adds synthetic fence tokens inline:
+ * - If the hunk starts inside a block: prepend ``` to the first content
+ *   line so the boundary closer has something to close.
+ * - If the hunk ends inside a block: append ``` to the last content
+ *   line so the boundary opener is properly closed.
+ * Tokens are added inline (no new lines) to preserve patch header counts.
+ */
+function repairContextualFences(contentLines, lines, rule) {
+    if (!rule.classifyFence)
+        return [...lines];
+    const occurrences = findDelimiterOccurrences(contentLines, rule.token);
+    if (occurrences.length === 0)
+        return [...lines];
+    // Classify each occurrence as fence open, close, or not-a-fence
+    const fences = [];
+    for (const occ of occurrences) {
+        const content = contentLines[occ.contentLineIndex]?.content;
+        if (!content)
+            continue;
+        const kind = rule.classifyFence(content, occ.column);
+        if (kind) {
+            fences.push({ occurrence: occ, kind });
+        }
+    }
+    if (fences.length === 0)
+        return [...lines];
+    // Try both starting states
+    const walk0 = walkFences(fences, 0);
+    const walk1 = walkFences(fences, 1);
+    // Pick better walk: fewer conflicts → fewer repairs → content heuristic
+    let chosen;
+    if (walk0.conflicts < walk1.conflicts) {
+        chosen = walk0;
+    }
+    else if (walk1.conflicts < walk0.conflicts) {
+        chosen = walk1;
+    }
+    else {
+        const repairs0 = (walk0.startDepth > 0 ? 1 : 0) + (walk0.endDepth > 0 ? 1 : 0);
+        const repairs1 = (walk1.startDepth > 0 ? 1 : 0) + (walk1.endDepth > 0 ? 1 : 0);
+        if (repairs0 < repairs1) {
+            chosen = walk0;
+        }
+        else if (repairs1 < repairs0) {
+            chosen = walk1;
+        }
+        else {
+            // Still tied: disambiguate by content position relative to the first fence.
+            // If there's non-empty content before the first fence in the hunk, the fence
+            // is likely closing a block from before the hunk → prefer depth=1 (starts inside).
+            // This produces better tree-sitter pairing: the prepended ``` + original ```
+            // form a matched pair, while appended inline ``` doesn't close a fence.
+            const firstIdx = fences[0]?.occurrence.contentLineIndex ?? 0;
+            const hasContentBefore = contentLines.slice(0, firstIdx).some((line) => line.content.trim() !== "");
+            chosen = hasContentBefore ? walk1 : walk0;
+        }
+    }
+    let result = [...lines];
+    // Append synthetic closer to end of last content line (inline, no new lines)
+    if (chosen.endDepth > 0) {
+        result = appendClosingTokensToLastContentLine(result, rule.token, 1);
+    }
+    // Prepend synthetic opener to start of first content line (inline, no new lines).
+    // Pass the first fence's hunk line index so the search only looks at lines
+    // before the boundary closer — the opener must precede it to form a pair.
+    if (chosen.startDepth > 0) {
+        const firstFenceHunkLine = fences[0]?.occurrence.hunkLineIndex;
+        result = prependOpeningTokenToFirstContentLine(result, rule.token, firstFenceHunkLine);
+    }
+    return result;
+}
+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}`;
+    });
+}
+function prependOpeningTokenToFirstContentLine(lines, openToken, beforeHunkLineIndex) {
+    // Prefer a blank/whitespace content line to avoid creating a fake info string
+    // (e.g. "```   handler() {" makes tree-sitter think "handler()" is a language).
+    // Only search among lines BEFORE the first fence so the synthetic opener
+    // appears before the boundary closer (they need to pair).
+    const firstContentLineIndex = lines.findIndex(isDiffContentLine);
+    if (firstContentLineIndex === -1) {
+        return [...lines];
+    }
+    const searchEnd = beforeHunkLineIndex ?? lines.length;
+    let targetIndex = firstContentLineIndex;
+    for (let i = firstContentLineIndex; i < searchEnd; i++) {
+        const line = lines[i];
+        if (!isDiffContentLine(line))
+            continue;
+        if (line.slice(1).trim() === "") {
+            targetIndex = i;
+            break;
+        }
+    }
+    return lines.map((line, index) => {
+        if (index !== targetIndex || !isDiffContentLine(line)) {
+            return line;
+        }
+        const prefix = line[0] ?? "";
+        const content = line.slice(1);
+        return `${prefix}${openToken} ${content}`;
+    });
+}
 /**
  * Balance paired delimiters in a unified diff patch for correct syntax
  * highlighting.
@@ -61,20 +417,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 +447,48 @@ 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;
+            }
+            // Contextual fence pairing (markdown code fences): uses sequential
+            // open/close tracking instead of simple odd/even parity.
+            if (rule.classifyFence) {
+                repairedLines = repairContextualFences(contentLines, repairedLines, 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");
 }