@wonderwhy-er/desktop-commander 0.2.39 → 0.2.40

package/dist/ui/file-preview/src/markdown/controller.d.ts

@@ -1,5 +1,5 @@
 import type { MarkdownWorkspaceState, RenderBodyResult, RenderPayload } from '../model.js';
-import { type MarkdownEditorView } from './editor.js';
+import { type MarkdownEditRange, type MarkdownEditorView } from './editor.js';
 import type { OpenConflictDialogOptions } from './conflict-dialog.js';
 export interface MarkdownControllerDependencies {
     callTool?: (name: string, args: Record<string, unknown>) => Promise<unknown | undefined>;
@@ -16,6 +16,11 @@ export interface MarkdownControllerDependencies {
     trackUiEvent?: (event: string, params?: Record<string, unknown>) => void;
     showConflictDialog?: (options: OpenConflictDialogOptions) => void;
 }
+interface EditBlock {
+    old_string: string;
+    new_string: string;
+}
+export declare function computeEditBlocks(oldText: string, newText: string, changedRanges?: MarkdownEditRange[]): EditBlock[];
 export declare function createMarkdownController(dependencies: MarkdownControllerDependencies): {
     attachHandlers: (payload: RenderPayload) => void;
     buildBody: (payload: RenderPayload) => RenderBodyResult;
@@ -36,3 +41,4 @@ export declare function createMarkdownController(dependencies: MarkdownControlle
     setEditorView: (payload: RenderPayload, view: MarkdownEditorView) => void;
 };
 export type MarkdownController = ReturnType<typeof createMarkdownController>;
+export {};

package/dist/ui/file-preview/src/markdown/controller.js

@@ -8,6 +8,7 @@ import { extractMarkdownOutline } from './outline.js';
 import { getRenderedMarkdownCopyText } from './preview.js';
 import { slugifyMarkdownHeading } from './slugify.js';
 import { getFileExtensionForAnalytics } from '../payload-utils.js';
+const MAX_EDIT_BLOCK_LINES = 40;
 function areOutlineItemsEqual(left, right) {
     if (left.length !== right.length) {
         return false;
@@ -35,9 +36,6 @@ function stripMarkdownExtension(filePath) {
 function computeDiffHunks(oldLines, newLines) {
     const oldLength = oldLines.length;
     const newLength = newLines.length;
-    if (oldLength * newLength > 1000000) {
-        return [{ oldStart: 0, oldEnd: oldLength, newStart: 0, newEnd: newLength }];
-    }
     const dp = Array.from({ length: oldLength + 1 }, () => Array(newLength + 1).fill(0));
     for (let i = 1; i <= oldLength; i += 1) {
         for (let j = 1; j <= newLength; j += 1) {
@@ -94,23 +92,113 @@ function mergeCloseHunks(hunks, minGap) {
     }
     return merged;
 }
-function computeEditBlocks(oldText, newText) {
+function mergeLineRanges(ranges) {
+    const sorted = ranges
+        .map((range) => ({ fromLine: Math.max(1, Math.floor(range.fromLine)), toLine: Math.max(1, Math.floor(range.toLine)) }))
+        .sort((left, right) => left.fromLine - right.fromLine || left.toLine - right.toLine);
+    const merged = [];
+    for (const range of sorted) {
+        const normalized = {
+            fromLine: Math.min(range.fromLine, range.toLine),
+            toLine: Math.max(range.fromLine, range.toLine),
+        };
+        const previous = merged[merged.length - 1];
+        if (previous && normalized.fromLine <= previous.toLine + 1) {
+            previous.toLine = Math.max(previous.toLine, normalized.toLine);
+        }
+        else {
+            merged.push(normalized);
+        }
+    }
+    return merged;
+}
+function hunkIntersectsRanges(hunk, ranges) {
+    if (ranges.length === 0) {
+        return true;
+    }
+    const fromLine = Math.min(hunk.oldStart, hunk.newStart) + 1;
+    const toLine = Math.max(hunk.oldEnd, hunk.newEnd) + 1;
+    return ranges.some((range) => fromLine <= range.toLine && toLine >= range.fromLine);
+}
+function computeLineByLineHunks(oldLines, newLines) {
+    return computeAnchoredDiffHunks(oldLines, newLines, 0, oldLines.length, 0, newLines.length);
+}
+function computeAnchoredDiffHunks(oldLines, newLines, oldStart, oldEnd, newStart, newEnd) {
+    while (oldStart < oldEnd && newStart < newEnd && oldLines[oldStart] === newLines[newStart]) {
+        oldStart++;
+        newStart++;
+    }
+    while (oldStart < oldEnd && newStart < newEnd && oldLines[oldEnd - 1] === newLines[newEnd - 1]) {
+        oldEnd--;
+        newEnd--;
+    }
+    if (oldStart === oldEnd && newStart === newEnd) {
+        return [];
+    }
+    const oldLineCounts = new Map();
+    const newLineCounts = new Map();
+    for (let index = oldStart; index < oldEnd; index += 1) {
+        const current = oldLineCounts.get(oldLines[index]);
+        oldLineCounts.set(oldLines[index], { count: (current?.count ?? 0) + 1, index });
+    }
+    for (let index = newStart; index < newEnd; index += 1) {
+        const current = newLineCounts.get(newLines[index]);
+        newLineCounts.set(newLines[index], { count: (current?.count ?? 0) + 1, index });
+    }
+    for (let oldIndex = oldStart; oldIndex < oldEnd; oldIndex += 1) {
+        const oldEntry = oldLineCounts.get(oldLines[oldIndex]);
+        const newEntry = newLineCounts.get(oldLines[oldIndex]);
+        if (oldEntry?.count === 1 && newEntry?.count === 1) {
+            return [
+                ...computeAnchoredDiffHunks(oldLines, newLines, oldStart, oldIndex, newStart, newEntry.index),
+                ...computeAnchoredDiffHunks(oldLines, newLines, oldIndex + 1, oldEnd, newEntry.index + 1, newEnd),
+            ];
+        }
+    }
+    return [{ oldStart, oldEnd, newStart, newEnd }];
+}
+function splitOversizedEditBlock(oldText, newText) {
+    const oldLines = oldText.split('\n');
+    const newLines = newText.split('\n');
+    const blockCount = Math.ceil(Math.max(oldLines.length, newLines.length) / MAX_EDIT_BLOCK_LINES);
+    const blocks = [];
+    for (let blockIndex = 0; blockIndex < blockCount; blockIndex += 1) {
+        const oldStart = Math.floor((blockIndex * oldLines.length) / blockCount);
+        const oldEnd = Math.floor(((blockIndex + 1) * oldLines.length) / blockCount);
+        const newStart = Math.floor((blockIndex * newLines.length) / blockCount);
+        const newEnd = Math.floor(((blockIndex + 1) * newLines.length) / blockCount);
+        const old_string = oldLines.slice(oldStart, oldEnd).join('\n');
+        const new_string = newLines.slice(newStart, newEnd).join('\n');
+        if (old_string !== new_string) {
+            blocks.push({ old_string, new_string });
+        }
+    }
+    return blocks;
+}
+function splitOversizedEditBlocks(blocks) {
+    return blocks.flatMap((block) => {
+        const lineCount = Math.max(block.old_string.split('\n').length, block.new_string.split('\n').length);
+        return lineCount > MAX_EDIT_BLOCK_LINES
+            ? splitOversizedEditBlock(block.old_string, block.new_string)
+            : [block];
+    });
+}
+export function computeEditBlocks(oldText, newText, changedRanges = []) {
     if (oldText === newText) {
         return [];
     }
     const oldLines = oldText.split('\n');
     const newLines = newText.split('\n');
-    const hunks = computeDiffHunks(oldLines, newLines);
+    const hunks = oldLines.length * newLines.length > 1000000
+        ? computeLineByLineHunks(oldLines, newLines)
+        : computeDiffHunks(oldLines, newLines);
     if (hunks.length === 0) {
         return [];
     }
     const context = 3;
-    const merged = mergeCloseHunks(hunks, context * 2 + 1);
-    const totalChanged = merged.reduce((sum, hunk) => sum + (hunk.oldEnd - hunk.oldStart), 0);
-    if (totalChanged > oldLines.length * 0.7) {
-        return [{ old_string: oldText, new_string: newText }];
-    }
-    return merged.map((hunk) => {
+    const normalizedRanges = mergeLineRanges(changedRanges);
+    const merged = mergeCloseHunks(hunks, context * 2 + 1).filter((hunk) => hunkIntersectsRanges(hunk, normalizedRanges));
+    const blocks = merged.map((hunk) => {
         const contextBefore = Math.max(0, hunk.oldStart - context);
         const contextAfter = Math.min(oldLines.length, hunk.oldEnd + context);
         const oldBlock = oldLines.slice(contextBefore, contextAfter).join('\n');
@@ -121,6 +209,13 @@ function computeEditBlocks(oldText, newText) {
         ].join('\n');
         return { old_string: oldBlock, new_string: newBlock };
     }).filter((block) => block.old_string !== block.new_string);
+    if (blocks.length === 1 && blocks[0].old_string === oldText && blocks[0].new_string === newText) {
+        return splitOversizedEditBlock(oldText, newText);
+    }
+    return splitOversizedEditBlocks(blocks);
+}
+function applyEditBlocksToText(text, blocks) {
+    return blocks.reduce((current, block) => current.replace(block.old_string, block.new_string), text);
 }
 function isToolErrorResult(value) {
     return typeof value === 'object' && value !== null;
@@ -176,6 +271,7 @@ export function createMarkdownController(dependencies) {
         state.draftContent = nextDraftContent;
         state.outline = extractMarkdownOutline(content);
         state.dirty = nextDraftContent !== content;
+        state.dirtyLineRanges = [];
         state.fileDeleted = false;
         if (!state.outline.some((item) => item.id === state.activeHeadingId)) {
             state.activeHeadingId = state.outline[0]?.id ?? null;
@@ -217,6 +313,7 @@ export function createMarkdownController(dependencies) {
                 outline,
                 mode: 'edit',
                 dirty: false,
+                dirtyLineRanges: [],
                 activeHeadingId: outline[0]?.id ?? null,
                 pendingAnchor: null,
                 notice: null,
@@ -541,6 +638,7 @@ export function createMarkdownController(dependencies) {
         const filePath = workspaceState.filePath;
         workspaceState.draftContent = workspaceState.fullDocumentContent;
         workspaceState.dirty = false;
+        workspaceState.dirtyLineRanges = [];
         workspaceState.error = null;
         workspaceState.notice = null;
         dependencies.rerender();
@@ -560,11 +658,12 @@ export function createMarkdownController(dependencies) {
         state.error = null;
         state.notice = null;
         try {
-            const blocks = computeEditBlocks(state.fullDocumentContent, state.draftContent);
+            const blocks = computeEditBlocks(state.fullDocumentContent, state.draftContent, state.dirtyLineRanges);
             if (blocks.length === 0) {
                 state.saving = false;
                 state.saveIndicator = 'idle';
                 state.dirty = false;
+                state.dirtyLineRanges = [];
                 return;
             }
             // Try each hunk independently. Previously the loop threw on the
@@ -606,16 +705,18 @@ export function createMarkdownController(dependencies) {
                 err.underlyingError = lastHardError;
                 throw err;
             }
-            state.fullDocumentContent = state.draftContent;
-            state.sourceContent = state.draftContent;
+            const savedContent = applyEditBlocksToText(state.fullDocumentContent, blocks);
+            state.fullDocumentContent = savedContent;
+            state.sourceContent = savedContent;
+            state.draftContent = savedContent;
             state.outline = extractMarkdownOutline(state.sourceContent);
             state.dirty = false;
+            state.dirtyLineRanges = [];
             state.saving = false;
             state.saveIndicator = 'saved';
             if (!state.outline.some((item) => item.id === state.activeHeadingId)) {
                 state.activeHeadingId = state.outline[0]?.id ?? null;
             }
-            const savedContent = state.draftContent;
             const currentPayload = dependencies.getCurrentPayload();
             if (currentPayload) {
                 const statusLineMatch = currentPayload.content.match(/^(\[Reading [^\]]+\]\r?\n(?:\r?\n)?)/);
@@ -788,9 +889,24 @@ export function createMarkdownController(dependencies) {
                     currentFilePath: payload.filePath,
                     searchLinks: (query) => searchLinkTargets(payload.filePath, query),
                     loadHeadings: (targetPath) => loadLinkHeadings(payload.filePath, targetPath),
-                    onChange: (value) => {
+                    onChange: (value, editRanges) => {
+                        if (value === state.draftContent) {
+                            return;
+                        }
                         state.draftContent = value;
                         state.dirty = value !== state.fullDocumentContent;
+                        if (state.dirty) {
+                            const nextRanges = editRanges && editRanges.length > 0
+                                ? editRanges
+                                : [{ fromLine: 1, toLine: value.split('\n').length }];
+                            state.dirtyLineRanges = mergeLineRanges([
+                                ...state.dirtyLineRanges,
+                                ...nextRanges,
+                            ]);
+                        }
+                        else {
+                            state.dirtyLineRanges = [];
+                        }
                         if (state.dirty && !editStartedFired) {
                             editStartedFired = true;
                             dependencies.trackUiEvent?.('markdown_edit_started', {
@@ -818,6 +934,9 @@ export function createMarkdownController(dependencies) {
                         }
                     },
                     onBlur: () => {
+                        if (!state.dirty) {
+                            return;
+                        }
                         cancelAutosave();
                         void saveDocument();
                     },

package/dist/ui/file-preview/src/markdown/editor.d.ts

@@ -1,4 +1,96 @@
+import type { Extensions } from '@tiptap/core';
 export type MarkdownEditorView = 'raw' | 'markdown';
+/**
+ * Round-trip safety wrapper around Tiptap.
+ *
+ * Tiptap parses markdown into ProseMirror nodes and serializes back via
+ * tiptap-markdown. Both steps are inherently lossy — features like GFM
+ * tables, wikilinks, YAML frontmatter, escapable characters and exact
+ * whitespace can't be recovered exactly from the parsed tree. The wrappers
+ * below preserve those features by:
+ *
+ *   1. Stripping content the editor can't safely round-trip (YAML
+ *      frontmatter, CRLF line endings) BEFORE handing markdown to Tiptap,
+ *      and re-attaching it after serialization.
+ *   2. Calling existing helpers (rewriteWikiLinks / restoreWikiLinks) that
+ *      replace `[[Page]]` with placeholder syntax Tiptap understands,
+ *      then put it back on the way out.
+ *   3. Preserving a trailing newline if the original document ended with
+ *      one — Tiptap's serializer always strips it.
+ *
+ * The shape of the safe region we save is captured in a `RoundTripContext`
+ * so post-processing can mirror it back. The test suite imports these
+ * helpers directly so the regression suite tests the EXACT same code path
+ * that production runs at autosave time.
+ */
+export interface RoundTripContext {
+    /** Original document text, retained for any final repair pass. */
+    originalInput: string;
+    /** YAML frontmatter prefix (`---\n…\n---\n`) stripped before editing. */
+    frontmatter: string;
+    /** Newlines between frontmatter end and first body line. Tiptap strips
+     *  these; we put them back exactly. */
+    frontmatterGap: string;
+    /** Trailing newline that was on the original; restored after serialize. */
+    trailingNewline: string;
+    /** EOL convention of the original (`'\r\n'` or `'\n'`). */
+    eol: '\r\n' | '\n';
+    /** Code-text links (`[\`x\`](url)`) replaced with placeholders during
+     *  preprocessing, restored after serialization. tiptap-markdown drops
+     *  the URL when a link's text is purely inline code. */
+    codeLinks: Array<{
+        placeholder: string;
+        original: string;
+    }>;
+    /** `**...\`code\`...**` constructs replaced with placeholders. Tiptap's
+     *  ProseMirror schema can't cleanly represent a bold mark wrapping
+     *  inline code; it splits the bold around the code in non-obvious
+     *  ways. */
+    boldCodeRuns: Array<{
+        placeholder: string;
+        original: string;
+    }>;
+    /** Count of `\|` escapes that were replaced with placeholders during
+     *  preprocess. Each `\|` is replaced by a single ASCII token that
+     *  restoration converts back to the literal `\|` in the output. */
+    pipeEscapeCount: number;
+}
+/**
+ * Pre-process a document before handing it to Tiptap. Returns a context
+ * object that `applyPostProcess` uses to restore stripped portions.
+ */
+export declare function preprocessForEditor(input: string): {
+    editorInput: string;
+    context: RoundTripContext;
+};
+/**
+ * Post-process the markdown Tiptap emits back into the user's expected
+ * form: re-attach frontmatter, restore wikilink syntax, restore trailing
+ * newline, undo unnecessary character escapes, and re-apply the original
+ * EOL convention.
+ */
+export declare function applyPostProcess(serialized: string, context: RoundTripContext): string;
+/**
+ * Build the Tiptap extension array used by both production and the test
+ * suite. Centralising this means the regression tests exercise the exact
+ * configuration that ships, so any fix here flows through to autosave too.
+ *
+ * Notable choices:
+ *   - StarterKit's strike extension is DISABLED. The default behaviour
+ *     escapes literal `~` to `\~` (and breaks `~/path`) on serialize,
+ *     because tiptap-markdown configures markdown-it with the strike
+ *     plugin enabled, which in turn enables `~` as an escape target.
+ *     Disabling strike costs us nothing visible (the editor never offered
+ *     a strike button) and unblocks two #440 corruption modes.
+ */
+export declare function buildTiptapExtensions(): Extensions;
+/**
+ * Convenience wrapper for tests and tools that want to mount the editor,
+ * call getMarkdown(), tear down, all in one shot. Production uses the
+ * pieces individually (preprocessForEditor at mount time, getMarkdown
+ * during autosave, applyPostProcess before writing to disk).
+ */
+export declare function roundTripMarkdown(input: string): string;
 export interface MarkdownLinkSearchItem {
     path: string;
     title: string;
@@ -17,6 +109,10 @@ export interface MarkdownEditorHandle {
     revealLine: (lineNumber: number, headingId?: string) => void;
     setScrollTop: (scrollTop: number) => void;
 }
+export interface MarkdownEditRange {
+    fromLine: number;
+    toLine: number;
+}
 export declare function renderMarkdownCopyButton(): string;
 export declare function renderMarkdownModeToggle(view: MarkdownEditorView): string;
 export declare function renderMarkdownEditorShell(options: {
@@ -30,6 +126,6 @@ export declare function mountMarkdownEditor(options: {
     currentFilePath: string;
     searchLinks?: (query: string) => Promise<MarkdownLinkSearchItem[]>;
     loadHeadings?: (filePath: string) => Promise<MarkdownLinkHeading[]>;
-    onChange: (value: string) => void;
+    onChange: (value: string, editRanges?: MarkdownEditRange[]) => void;
     onBlur?: () => void;
 }): MarkdownEditorHandle;