typst-mcp 1.0.2 → 1.2.0

package/dist/protocol/edit-diff.js

@@ -0,0 +1,330 @@
+/**
+ * Surgical text editing and diff utilities, adapted from Pi (earendil-works/pi).
+ */
+import * as Diff from "diff";
+export function detectLineEnding(content) {
+    const crlfIdx = content.indexOf("\r\n");
+    const lfIdx = content.indexOf("\n");
+    if (lfIdx === -1)
+        return "\n";
+    if (crlfIdx === -1)
+        return "\n";
+    return crlfIdx < lfIdx ? "\r\n" : "\n";
+}
+export function normalizeToLF(text) {
+    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+export function restoreLineEndings(text, ending) {
+    return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
+}
+export function splitBom(text) {
+    if (text.charCodeAt(0) === 0xfeff) {
+        return { bom: "\uFEFF", text: text.slice(1) };
+    }
+    return { bom: "", text };
+}
+/**
+ * Normalize text for fuzzy matching:
+ * - NFKC unicode normalization
+ * - Strip trailing whitespace per line
+ * - Smart quotes -> ' and "
+ * - Unicode dashes/hyphens -> -
+ * - Special spaces -> standard space
+ */
+export function normalizeForFuzzyMatch(text) {
+    return (text
+        .normalize("NFKC")
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .join("\n")
+        // Smart single quotes
+        .replace(/[\u2018\u2019\u201A\u201B]/g, "'")
+        // Smart double quotes
+        .replace(/[\u201C\u201D\u201E\u201F]/g, '"')
+        // Various dashes/hyphens
+        .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-")
+        // Special spaces
+        .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " "));
+}
+function splitLinesWithEndings(content) {
+    return content.match(/[^\n]*\n|[^\n]+/g) ?? [];
+}
+function getLineSpans(content) {
+    let offset = 0;
+    return splitLinesWithEndings(content).map((line) => {
+        const span = { start: offset, end: offset + line.length };
+        offset = span.end;
+        return span;
+    });
+}
+function getReplacementLineRange(lines, replacement) {
+    const replacementStart = replacement.matchIndex;
+    const replacementEnd = replacement.matchIndex + replacement.matchLength;
+    let startLine = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (replacementStart >= line.start && replacementStart < line.end) {
+            startLine = i;
+            break;
+        }
+    }
+    if (startLine === -1) {
+        throw new Error("Replacement range is outside base content");
+    }
+    let endLine = startLine;
+    while (endLine < lines.length && lines[endLine].end < replacementEnd) {
+        endLine++;
+    }
+    if (endLine >= lines.length) {
+        throw new Error("Replacement range is outside base content");
+    }
+    return { startLine, endLine: endLine + 1 };
+}
+function applyReplacements(content, replacements, offset = 0) {
+    let result = content;
+    for (let i = replacements.length - 1; i >= 0; i--) {
+        const replacement = replacements[i];
+        const matchIndex = replacement.matchIndex - offset;
+        result =
+            result.substring(0, matchIndex) +
+                replacement.newText +
+                result.substring(matchIndex + replacement.matchLength);
+    }
+    return result;
+}
+export function applyReplacementsPreservingUnchangedLines(originalContent, baseContent, replacements) {
+    const originalLines = splitLinesWithEndings(originalContent);
+    const baseLines = getLineSpans(baseContent);
+    if (originalLines.length !== baseLines.length) {
+        throw new Error("Cannot preserve unchanged lines: base content has different line count");
+    }
+    const groups = [];
+    const sortedReplacements = [...replacements].sort((a, b) => a.matchIndex - b.matchIndex);
+    for (const replacement of sortedReplacements) {
+        const range = getReplacementLineRange(baseLines, replacement);
+        const current = groups[groups.length - 1];
+        if (current && range.startLine < current.endLine) {
+            current.endLine = Math.max(current.endLine, range.endLine);
+            current.replacements.push(replacement);
+            continue;
+        }
+        groups.push({ ...range, replacements: [replacement] });
+    }
+    let originalLineIndex = 0;
+    let result = "";
+    for (const group of groups) {
+        result += originalLines.slice(originalLineIndex, group.startLine).join("");
+        const groupStartOffset = baseLines[group.startLine].start;
+        const groupEndOffset = baseLines[group.endLine - 1].end;
+        result += applyReplacements(baseContent.slice(groupStartOffset, groupEndOffset), group.replacements, groupStartOffset);
+        originalLineIndex = group.endLine;
+    }
+    result += originalLines.slice(originalLineIndex).join("");
+    return result;
+}
+export function fuzzyFindText(content, oldText) {
+    const exactIndex = content.indexOf(oldText);
+    if (exactIndex !== -1) {
+        return {
+            found: true,
+            index: exactIndex,
+            matchLength: oldText.length,
+            usedFuzzyMatch: false,
+            contentForReplacement: content,
+        };
+    }
+    const fuzzyContent = normalizeForFuzzyMatch(content);
+    const fuzzyOldText = normalizeForFuzzyMatch(oldText);
+    const fuzzyIndex = fuzzyContent.indexOf(fuzzyOldText);
+    if (fuzzyIndex === -1) {
+        return {
+            found: false,
+            index: -1,
+            matchLength: 0,
+            usedFuzzyMatch: false,
+            contentForReplacement: content,
+        };
+    }
+    return {
+        found: true,
+        index: fuzzyIndex,
+        matchLength: fuzzyOldText.length,
+        usedFuzzyMatch: true,
+        contentForReplacement: fuzzyContent,
+    };
+}
+export function countOccurrences(content, oldText) {
+    const fuzzyContent = normalizeForFuzzyMatch(content);
+    const fuzzyOldText = normalizeForFuzzyMatch(oldText);
+    if (fuzzyOldText.length === 0)
+        return 0;
+    return fuzzyContent.split(fuzzyOldText).length - 1;
+}
+export function applyEditsToNormalizedContent(normalizedContent, edits, path) {
+    const normalizedEdits = edits.map((e) => ({
+        oldText: normalizeToLF(e.oldText),
+        newText: normalizeToLF(e.newText),
+    }));
+    for (let i = 0; i < normalizedEdits.length; i++) {
+        if (normalizedEdits[i].oldText.length === 0) {
+            throw new Error(`oldText cannot be empty for edit in ${path}`);
+        }
+    }
+    const initialMatches = normalizedEdits.map((e) => fuzzyFindText(normalizedContent, e.oldText));
+    const usedFuzzyMatch = initialMatches.some((m) => m.usedFuzzyMatch);
+    const replacementBaseContent = usedFuzzyMatch
+        ? normalizeForFuzzyMatch(normalizedContent)
+        : normalizedContent;
+    const matchedEdits = [];
+    for (let i = 0; i < normalizedEdits.length; i++) {
+        const edit = normalizedEdits[i];
+        const matchResult = fuzzyFindText(replacementBaseContent, edit.oldText);
+        if (!matchResult.found) {
+            throw new Error(`Could not find match for oldText in ${path}: ${JSON.stringify(edit.oldText.slice(0, 80))}`);
+        }
+        const occurrences = countOccurrences(replacementBaseContent, edit.oldText);
+        if (occurrences > 1) {
+            throw new Error(`Found ${occurrences} occurrences of oldText in ${path} (must be unique): ${JSON.stringify(edit.oldText.slice(0, 80))}`);
+        }
+        matchedEdits.push({
+            editIndex: i,
+            matchIndex: matchResult.index,
+            matchLength: matchResult.matchLength,
+            newText: edit.newText,
+        });
+    }
+    matchedEdits.sort((a, b) => a.matchIndex - b.matchIndex);
+    for (let i = 1; i < matchedEdits.length; i++) {
+        const prev = matchedEdits[i - 1];
+        const curr = matchedEdits[i];
+        if (prev.matchIndex + prev.matchLength > curr.matchIndex) {
+            throw new Error(`Edits overlap in ${path}. Merge overlapping changes into a single edit.`);
+        }
+    }
+    const baseContent = normalizedContent;
+    const newContent = usedFuzzyMatch
+        ? applyReplacementsPreservingUnchangedLines(normalizedContent, replacementBaseContent, matchedEdits)
+        : applyReplacements(replacementBaseContent, matchedEdits);
+    if (baseContent === newContent) {
+        throw new Error(`No changes made to ${path}: newText equals oldText.`);
+    }
+    return { baseContent, newContent };
+}
+/**
+ * Generate a standard unified patch.
+ */
+export function generateUnifiedPatch(path, oldContent, newContent, contextLines = 4) {
+    return Diff.createTwoFilesPatch(path, path, oldContent, newContent, undefined, undefined, {
+        context: contextLines,
+    });
+}
+/**
+ * Generate a display-oriented diff string with line numbers and context.
+ */
+export function generateDiffString(oldContent, newContent, contextLines = 4) {
+    const parts = Diff.diffLines(oldContent, newContent);
+    const output = [];
+    const oldLines = oldContent.split("\n");
+    const newLines = newContent.split("\n");
+    const maxLineNum = Math.max(oldLines.length, newLines.length);
+    const lineNumWidth = String(maxLineNum).length;
+    let oldLineNum = 1;
+    let newLineNum = 1;
+    let lastWasChange = false;
+    let firstChangedLine;
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        const raw = part.value.split("\n");
+        if (raw[raw.length - 1] === "") {
+            raw.pop();
+        }
+        if (part.added || part.removed) {
+            if (firstChangedLine === undefined && part.added) {
+                firstChangedLine = newLineNum;
+            }
+            for (const line of raw) {
+                if (part.added) {
+                    const lineNum = String(newLineNum).padStart(lineNumWidth, " ");
+                    output.push(`+${lineNum} ${line}`);
+                    newLineNum++;
+                }
+                else {
+                    const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+                    output.push(`-${lineNum} ${line}`);
+                    oldLineNum++;
+                }
+            }
+            lastWasChange = true;
+        }
+        else {
+            const nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
+            const hasLeadingChange = lastWasChange;
+            const hasTrailingChange = nextPartIsChange;
+            if (hasLeadingChange && hasTrailingChange) {
+                if (raw.length <= contextLines * 2) {
+                    for (const line of raw) {
+                        const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+                        output.push(` ${lineNum} ${line}`);
+                        oldLineNum++;
+                        newLineNum++;
+                    }
+                }
+                else {
+                    const leadingLines = raw.slice(0, contextLines);
+                    const trailingLines = raw.slice(raw.length - contextLines);
+                    const skippedLines = raw.length - leadingLines.length - trailingLines.length;
+                    for (const line of leadingLines) {
+                        const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+                        output.push(` ${lineNum} ${line}`);
+                        oldLineNum++;
+                        newLineNum++;
+                    }
+                    output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+                    oldLineNum += skippedLines;
+                    newLineNum += skippedLines;
+                    for (const line of trailingLines) {
+                        const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+                        output.push(` ${lineNum} ${line}`);
+                        oldLineNum++;
+                        newLineNum++;
+                    }
+                }
+            }
+            else if (hasLeadingChange) {
+                const shownLines = raw.slice(0, contextLines);
+                const skippedLines = raw.length - shownLines.length;
+                for (const line of shownLines) {
+                    const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+                    output.push(` ${lineNum} ${line}`);
+                    oldLineNum++;
+                    newLineNum++;
+                }
+                if (skippedLines > 0) {
+                    output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+                    oldLineNum += skippedLines;
+                    newLineNum += skippedLines;
+                }
+            }
+            else if (hasTrailingChange) {
+                const skippedLines = Math.max(0, raw.length - contextLines);
+                if (skippedLines > 0) {
+                    output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+                    oldLineNum += skippedLines;
+                    newLineNum += skippedLines;
+                }
+                for (const line of raw.slice(skippedLines)) {
+                    const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+                    output.push(` ${lineNum} ${line}`);
+                    oldLineNum++;
+                    newLineNum++;
+                }
+            }
+            else {
+                oldLineNum += raw.length;
+                newLineNum += raw.length;
+            }
+            lastWasChange = false;
+        }
+    }
+    return { diff: output.join("\n"), firstChangedLine };
+}

package/dist/protocol/search-replace.js

@@ -0,0 +1,97 @@
+/**
+ * Search and global replace utilities for Typst projects.
+ */
+import { generateDiffString, generateUnifiedPatch } from "./edit-diff.js";
+export function matchGlob(path, pattern) {
+    if (!pattern || pattern === "*" || pattern === "**" || pattern === "**/*") {
+        return true;
+    }
+    const normalizedPath = path.replace(/^\/+/, "");
+    const fileName = normalizedPath.split("/").pop() ?? normalizedPath;
+    const escaped = pattern
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*\*/g, ".*")
+        .replace(/(?<!\.)\*/g, "[^/]*")
+        .replace(/\?/g, ".");
+    const re = new RegExp(`^${escaped}$`, "i");
+    return re.test(normalizedPath) || re.test(fileName);
+}
+export function searchInContent(filePath, content, options) {
+    const lines = content.split("\n");
+    const matches = [];
+    const limit = options.limit ?? 100;
+    const context = Math.max(0, options.context ?? 0);
+    let regex;
+    if (options.literal) {
+        const escaped = options.pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        regex = new RegExp(escaped, options.ignoreCase ? "i" : "");
+    }
+    else {
+        try {
+            regex = new RegExp(options.pattern, options.ignoreCase ? "i" : "");
+        }
+        catch {
+            const escaped = options.pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            regex = new RegExp(escaped, options.ignoreCase ? "i" : "");
+        }
+    }
+    let totalMatches = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (regex.test(line)) {
+            totalMatches++;
+            if (matches.length < limit) {
+                const contextBefore = context > 0 ? lines.slice(Math.max(0, i - context), i) : undefined;
+                const contextAfter = context > 0
+                    ? lines.slice(i + 1, Math.min(lines.length, i + 1 + context))
+                    : undefined;
+                matches.push({
+                    file: filePath,
+                    line: i + 1,
+                    text: line,
+                    contextBefore,
+                    contextAfter,
+                });
+            }
+        }
+    }
+    return { matches, totalMatches };
+}
+export function replaceInContent(filePath, content, options) {
+    let flags = "g";
+    if (options.ignoreCase)
+        flags += "i";
+    let searchRegex;
+    if (options.regex) {
+        searchRegex = new RegExp(options.pattern, flags);
+    }
+    else {
+        const escaped = options.pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        searchRegex = new RegExp(escaped, flags);
+    }
+    let count = 0;
+    const limit = options.limit;
+    const updatedText = content.replace(searchRegex, (match, ...args) => {
+        if (limit !== undefined && count >= limit) {
+            return match;
+        }
+        count++;
+        if (!options.regex) {
+            return options.replacement;
+        }
+        // For regex, support standard replacement with capture groups ($1, $2)
+        return options.replacement.replace(/\$(\d+)/g, (_, groupIdx) => {
+            const idx = parseInt(groupIdx, 10);
+            return args[idx - 1] ?? "";
+        });
+    });
+    const diffResult = generateDiffString(content, updatedText);
+    const patch = generateUnifiedPatch(filePath, content, updatedText);
+    return {
+        updatedText,
+        replacementCount: count,
+        diff: diffResult.diff,
+        patch,
+        firstChangedLine: diffResult.firstChangedLine,
+    };
+}

package/dist/protocol/yjs-doc.js

@@ -1,4 +1,6 @@
 import * as Y from "yjs";
+import * as Diff from "diff";
+import { applyEditsToNormalizedContent, detectLineEnding, generateDiffString, generateUnifiedPatch, normalizeToLF, restoreLineEndings, splitBom, } from "./edit-diff.js";
 function computeUpdateDiff(doc, remoteUpdate) {
     let stateVector;
     if (remoteUpdate.byteLength > 0) {
@@ -73,11 +75,11 @@ export function replaceYjsText(remoteUpdate, newContent) {
     }
 }
 /**
- * Applies one or more exact surgical text replacements (`oldText` -> `newText`)
- * directly on the `Y.Text("text")` CRDT so concurrent collaborator cursors and
- * history are preserved.
+ * Applies one or more surgical text replacements (`oldText` -> `newText`)
+ * directly on the `Y.Text("text")` CRDT, with CRLF/BOM resilience, fuzzy matching,
+ * and unified diff generation.
  */
-export function editYjsText(remoteUpdate, edits) {
+export function editYjsText(remoteUpdate, edits, filePath = "file") {
     if (edits.length === 0) {
         throw new Error("At least one edit operation is required");
     }
@@ -88,49 +90,40 @@ export function editYjsText(remoteUpdate, edits) {
         }
         const ytext = doc.getText("text");
         const previousText = ytext.toString();
-        const matchedRegions = [];
-        for (const edit of edits) {
-            if (!edit.oldText) {
-                throw new Error("oldText cannot be empty in surgical edit");
-            }
-            const firstIdx = previousText.indexOf(edit.oldText);
-            if (firstIdx === -1) {
-                throw new Error(`Could not find exact oldText match: ${JSON.stringify(edit.oldText.slice(0, 80))}`);
-            }
-            const secondIdx = previousText.indexOf(edit.oldText, firstIdx + 1);
-            if (secondIdx !== -1) {
-                throw new Error(`oldText is not unique in file (found at offset ${firstIdx} and ${secondIdx}): ${JSON.stringify(edit.oldText.slice(0, 80))}`);
-            }
-            matchedRegions.push({
-                start: firstIdx,
-                end: firstIdx + edit.oldText.length,
-                oldText: edit.oldText,
-                newText: edit.newText,
-            });
-        }
-        matchedRegions.sort((a, b) => b.start - a.start);
-        for (let i = 0; i < matchedRegions.length - 1; i++) {
-            const upper = matchedRegions[i];
-            const lower = matchedRegions[i + 1];
-            if (lower.end > upper.start) {
-                throw new Error(`Overlapping edit regions detected between [${lower.start}, ${lower.end}) and [${upper.start}, ${upper.end})`);
-            }
-        }
+        const { bom, text: contentWithoutBom } = splitBom(previousText);
+        const originalEnding = detectLineEnding(contentWithoutBom);
+        const normalizedContent = normalizeToLF(contentWithoutBom);
+        const { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, filePath);
+        const finalContent = bom + restoreLineEndings(newContent, originalEnding);
+        // Apply minimal surgical character changes to Y.Text
+        const diffs = Diff.diffChars(previousText, finalContent);
         doc.transact(() => {
-            for (const region of matchedRegions) {
-                ytext.delete(region.start, region.oldText.length);
-                if (region.newText.length > 0) {
-                    ytext.insert(region.start, region.newText);
+            let offset = 0;
+            for (const part of diffs) {
+                if (part.added) {
+                    ytext.insert(offset, part.value);
+                    offset += part.value.length;
+                }
+                else if (part.removed) {
+                    ytext.delete(offset, part.value.length);
+                }
+                else {
+                    offset += part.value.length;
                 }
             }
         });
         const { encodedUpdate, mergedState } = computeUpdateDiff(doc, remoteUpdate);
+        const diffResult = generateDiffString(baseContent, newContent);
+        const patch = generateUnifiedPatch(filePath, baseContent, newContent);
         return {
             encodedUpdate,
             mergedState,
             previousText,
-            updatedText: ytext.toString(),
-            appliedCount: matchedRegions.length,
+            updatedText: finalContent,
+            appliedCount: edits.length,
+            diff: diffResult.diff,
+            patch,
+            firstChangedLine: diffResult.firstChangedLine,
         };
     }
     finally {