@wonderwhy-er/desktop-commander 0.2.39 → 0.2.40

package/dist/ui/file-preview/src/components/markdown-editor.js

@@ -1,535 +0,0 @@
-/**
- * WYSIWYG markdown editor for the file preview. Makes rendered markdown
- * blocks contentEditable and translates user changes back to markdown
- * source, calling edit_block for surgical file updates.
- */
-import { renderMarkdown } from './markdown-renderer.js';
-import { createEditorToolbar, handleFormatKeydown } from './editor-toolbar.js';
-// ---------------------------------------------------------------------------
-// Markdown source → blocks parser
-// ---------------------------------------------------------------------------
-export function parseMarkdownBlocks(source) {
-    const lines = source.split('\n');
-    const blocks = [];
-    let i = 0;
-    while (i < lines.length) {
-        const line = lines[i];
-        // Blank line — skip
-        if (line.trim() === '') {
-            i++;
-            continue;
-        }
-        // Fenced code block (``` or ~~~)
-        const fenceMatch = line.match(/^(`{3,}|~{3,})/);
-        if (fenceMatch) {
-            const fence = fenceMatch[1];
-            const start = i;
-            i++;
-            while (i < lines.length && !lines[i].startsWith(fence))
-                i++;
-            if (i < lines.length)
-                i++; // closing fence
-            blocks.push({
-                type: 'code',
-                source: lines.slice(start, i).join('\n'),
-                startLine: start + 1,
-                endLine: i,
-                editable: false,
-            });
-            continue;
-        }
-        // Setext heading (underline with = or -)
-        if (i + 1 < lines.length &&
-            /^[=-]+\s*$/.test(lines[i + 1]) &&
-            line.trim() !== '') {
-            const level = lines[i + 1].startsWith('=') ? 1 : 2;
-            blocks.push({
-                type: 'heading',
-                source: lines.slice(i, i + 2).join('\n'),
-                startLine: i + 1,
-                endLine: i + 2,
-                level,
-                editable: true,
-            });
-            i += 2;
-            continue;
-        }
-        // ATX heading
-        const headingMatch = line.match(/^(#{1,6})\s+(.*)/);
-        if (headingMatch) {
-            blocks.push({
-                type: 'heading',
-                source: line,
-                startLine: i + 1,
-                endLine: i + 1,
-                level: headingMatch[1].length,
-                editable: true,
-            });
-            i++;
-            continue;
-        }
-        // Horizontal rule
-        if (/^(-{3,}|\*{3,}|_{3,})\s*$/.test(line)) {
-            blocks.push({
-                type: 'hr',
-                source: line,
-                startLine: i + 1,
-                endLine: i + 1,
-                editable: false,
-            });
-            i++;
-            continue;
-        }
-        // Blockquote
-        if (line.startsWith('>')) {
-            const start = i;
-            while (i < lines.length &&
-                (lines[i].startsWith('>') ||
-                    (lines[i].trim() !== '' && !isBlockStart(lines[i]) && i > start))) {
-                i++;
-                if (i < lines.length && lines[i].trim() === '')
-                    break;
-            }
-            blocks.push({
-                type: 'blockquote',
-                source: lines.slice(start, i).join('\n'),
-                startLine: start + 1,
-                endLine: i,
-                editable: true,
-            });
-            continue;
-        }
-        // List (unordered or ordered)
-        const listMatch = line.match(/^(\s*)([-*+]|\d+\.)\s/);
-        if (listMatch) {
-            const start = i;
-            const isOrdered = /\d+\./.test(listMatch[2]);
-            i++;
-            while (i < lines.length) {
-                const l = lines[i];
-                if (l.trim() === '') {
-                    // Blank inside list — check if next line continues the list
-                    if (i + 1 < lines.length && /^(\s*)([-*+]|\d+\.)\s/.test(lines[i + 1])) {
-                        i++;
-                        continue;
-                    }
-                    break;
-                }
-                if (/^(\s*)([-*+]|\d+\.)\s/.test(l) || /^\s+\S/.test(l)) {
-                    i++;
-                }
-                else {
-                    break;
-                }
-            }
-            blocks.push({
-                type: 'list',
-                source: lines.slice(start, i).join('\n'),
-                startLine: start + 1,
-                endLine: i,
-                listType: isOrdered ? 'ol' : 'ul',
-                editable: true,
-            });
-            continue;
-        }
-        // Table (pipe-delimited with separator row)
-        if (line.includes('|') &&
-            i + 1 < lines.length &&
-            /^\|?\s*[-:]+[-| :]*$/.test(lines[i + 1])) {
-            const start = i;
-            while (i < lines.length && lines[i].includes('|') && lines[i].trim() !== '')
-                i++;
-            blocks.push({
-                type: 'table',
-                source: lines.slice(start, i).join('\n'),
-                startLine: start + 1,
-                endLine: i,
-                editable: false,
-            });
-            continue;
-        }
-        // Paragraph (default — consecutive non-blank non-block-start lines)
-        {
-            const start = i;
-            i++;
-            while (i < lines.length && lines[i].trim() !== '' && !isBlockStart(lines[i])) {
-                i++;
-            }
-            blocks.push({
-                type: 'paragraph',
-                source: lines.slice(start, i).join('\n'),
-                startLine: start + 1,
-                endLine: i,
-                editable: true,
-            });
-        }
-    }
-    return blocks;
-}
-/** Returns true if a line starts a new block (heading, fence, hr, list, quote, table). */
-function isBlockStart(line) {
-    if (/^(#{1,6})\s/.test(line))
-        return true;
-    if (/^(`{3,}|~{3,})/.test(line))
-        return true;
-    if (/^(-{3,}|\*{3,}|_{3,})\s*$/.test(line))
-        return true;
-    if (line.startsWith('>'))
-        return true;
-    if (/^(\s*)([-*+]|\d+\.)\s/.test(line))
-        return true;
-    return false;
-}
-// ---------------------------------------------------------------------------
-// HTML → inline markdown conversion (for contentEditable round-tripping)
-// ---------------------------------------------------------------------------
-function nodeToMarkdown(node) {
-    if (node.nodeType === Node.TEXT_NODE) {
-        return node.textContent ?? '';
-    }
-    if (node.nodeType !== Node.ELEMENT_NODE)
-        return '';
-    const el = node;
-    const tag = el.tagName.toLowerCase();
-    const children = Array.from(el.childNodes).map(nodeToMarkdown).join('');
-    switch (tag) {
-        case 'strong':
-        case 'b':
-            return `**${children}**`;
-        case 'em':
-        case 'i':
-            return `*${children}*`;
-        case 'code':
-            // Inline code only (not inside <pre>)
-            if (!el.closest('pre'))
-                return `\`${el.textContent ?? ''}\``;
-            return children;
-        case 'a': {
-            const href = el.getAttribute('href') ?? '';
-            return `[${children}](${href})`;
-        }
-        case 'img': {
-            const alt = el.getAttribute('alt') ?? '';
-            const src = el.getAttribute('src') ?? '';
-            return `![${alt}](${src})`;
-        }
-        case 'br':
-            return '\n';
-        case 'del':
-        case 's':
-        case 'strike':
-            return `~~${children}~~`;
-        case 'span': {
-            // Preserve styled spans as inline HTML (color, font-size)
-            const style = el.getAttribute('style') ?? '';
-            if (style) {
-                return `<span style="${style}">${children}</span>`;
-            }
-            return children;
-        }
-        case 'font': {
-            // execCommand('foreColor') produces <font color="...">
-            // execCommand('fontSize') produces <font size="...">
-            const color = el.getAttribute('color');
-            const size = el.getAttribute('size');
-            if (color) {
-                return `<span style="color: ${color}">${children}</span>`;
-            }
-            if (size) {
-                return `<span style="font-size: ${size}">${children}</span>`;
-            }
-            return children;
-        }
-        default:
-            return children;
-    }
-}
-function extractInlineMarkdown(element) {
-    return Array.from(element.childNodes).map(nodeToMarkdown).join('').trim();
-}
-// ---------------------------------------------------------------------------
-// Block → markdown reconstruction from edited DOM
-// ---------------------------------------------------------------------------
-function blockToMarkdown(block, editedEl) {
-    switch (block.type) {
-        case 'heading': {
-            const prefix = '#'.repeat(block.level ?? 1);
-            const text = extractInlineMarkdown(editedEl);
-            return `${prefix} ${text}`;
-        }
-        case 'paragraph': {
-            const pTags = editedEl.querySelectorAll('p');
-            if (pTags.length > 0) {
-                return Array.from(pTags)
-                    .map(p => extractInlineMarkdown(p))
-                    .join('\n\n');
-            }
-            return extractInlineMarkdown(editedEl);
-        }
-        case 'list': {
-            const listItems = editedEl.querySelectorAll(':scope > li');
-            const isOrdered = block.listType === 'ol';
-            return Array.from(listItems)
-                .map((li, idx) => {
-                const liEl = li;
-                // markdown-it wraps loose list content in <p>
-                const pEl = liEl.querySelector(':scope > p');
-                const text = extractInlineMarkdown(pEl ?? liEl);
-                const prefix = isOrdered ? `${idx + 1}. ` : '- ';
-                return `${prefix}${text}`;
-            })
-                .join('\n');
-        }
-        case 'blockquote': {
-            const paragraphs = editedEl.querySelectorAll('p');
-            let text;
-            if (paragraphs.length > 0) {
-                text = Array.from(paragraphs)
-                    .map(p => extractInlineMarkdown(p))
-                    .join('\n\n');
-            }
-            else {
-                text = extractInlineMarkdown(editedEl);
-            }
-            return text
-                .split('\n')
-                .map(line => `> ${line}`)
-                .join('\n');
-        }
-        default:
-            return block.source;
-    }
-}
-// ---------------------------------------------------------------------------
-// Editable rendering — wraps each block in a container with data attributes
-// ---------------------------------------------------------------------------
-export function renderEditableMarkdown(source) {
-    const blocks = parseMarkdownBlocks(source);
-    let html = '';
-    for (const block of blocks) {
-        const rendered = renderMarkdown(block.source);
-        const editableClass = block.editable ? ' md-block--editable' : '';
-        const attrs = [
-            `data-md-start="${block.startLine}"`,
-            `data-md-end="${block.endLine}"`,
-            `data-md-type="${block.type}"`,
-            block.level !== undefined ? `data-md-level="${block.level}"` : '',
-            block.listType ? `data-md-list="${block.listType}"` : '',
-        ]
-            .filter(Boolean)
-            .join(' ');
-        html += `<div class="md-block${editableClass}" ${attrs}>${rendered}</div>`;
-    }
-    return html;
-}
-// ---------------------------------------------------------------------------
-// Editor handlers — attaches click/blur/keyboard editing to the DOM
-// ---------------------------------------------------------------------------
-/**
- * Find the inner content element that should become contentEditable.
- * Returns null for non-editable block types.
- */
-function getEditableChild(blockEl) {
-    const type = blockEl.dataset.mdType;
-    switch (type) {
-        case 'heading':
-            return blockEl.querySelector('h1, h2, h3, h4, h5, h6');
-        case 'paragraph':
-            return blockEl.querySelector('p') ?? blockEl;
-        case 'list':
-            return blockEl.querySelector('ul, ol');
-        case 'blockquote':
-            return blockEl.querySelector('blockquote');
-        default:
-            return null;
-    }
-}
-function truncate(text, maxLen) {
-    const singleLine = text.replace(/\n/g, ' ').trim();
-    return singleLine.length > maxLen ? singleLine.slice(0, maxLen) + '...' : singleLine;
-}
-/**
- * Attach WYSIWYG editing handlers to editable markdown blocks inside
- * the given container. All editable blocks are contentEditable from the
- * start — users can select and type immediately without an activation
- * click. Changes are committed when focus leaves the editor.
- */
-export function attachEditorHandlers(container, source, filePath, callbacks) {
-    const blocks = parseMarkdownBlocks(source);
-    const blockMap = new Map();
-    for (const block of blocks) {
-        blockMap.set(`${block.startLine}-${block.endLine}`, block);
-    }
-    // Snapshot each block's original innerHTML so we can detect changes
-    const originalHTML = new Map();
-    let activeBlockEl = null;
-    let activeEditEl = null;
-    const editHistory = [];
-    // Floating formatting toolbar
-    const toolbar = createEditorToolbar();
-    container.style.position = 'relative';
-    container.appendChild(toolbar.element);
-    // --- Make all editable blocks live from the start ---
-    const editableBlocks = container.querySelectorAll('.md-block--editable');
-    editableBlocks.forEach(blockEl => {
-        const editEl = getEditableChild(blockEl);
-        if (editEl) {
-            editEl.contentEditable = 'true';
-            const key = blockKey(blockEl);
-            originalHTML.set(key, editEl.innerHTML);
-        }
-    });
-    function blockKey(el) {
-        return `${el.dataset.mdStart}-${el.dataset.mdEnd}`;
-    }
-    async function commitBlock(blockEl, editEl) {
-        const key = blockKey(blockEl);
-        const block = blockMap.get(key);
-        if (!block)
-            return;
-        const origHTML = originalHTML.get(key);
-        if (editEl.innerHTML === origHTML)
-            return; // No change
-        const newMarkdown = blockToMarkdown(block, editEl);
-        if (newMarkdown === block.source)
-            return;
-        callbacks.trackEvent?.('md_block_edited', {
-            block_type: block.type,
-            line: block.startLine,
-        });
-        const prevSource = block.source;
-        try {
-            await callbacks.callTool('edit_block', {
-                file_path: filePath,
-                old_string: block.source,
-                new_string: newMarkdown,
-            });
-            block.source = newMarkdown;
-            editHistory.push({
-                oldText: prevSource,
-                newText: newMarkdown,
-                line: block.startLine,
-            });
-            // Re-render the block and make it editable again
-            const freshHtml = renderMarkdown(newMarkdown);
-            blockEl.innerHTML = freshHtml;
-            const newEditEl = getEditableChild(blockEl);
-            if (newEditEl) {
-                newEditEl.contentEditable = 'true';
-                originalHTML.set(key, newEditEl.innerHTML);
-            }
-            const recent = editHistory.slice(-5).map(e => `  - Line ${e.line}: "${truncate(e.oldText, 50)}" -> "${truncate(e.newText, 50)}"`);
-            callbacks.updateContext(`User edited ${filePath} via preview editor (${editHistory.length} edit${editHistory.length !== 1 ? 's' : ''}):\n${recent.join('\n')}`);
-        }
-        catch (err) {
-            // Revert on failure
-            if (origHTML !== undefined)
-                editEl.innerHTML = origHTML;
-            callbacks.trackEvent?.('md_edit_failed', {
-                block_type: block.type,
-                error: String(err),
-            });
-        }
-    }
-    // --- Track which block the user is in via focusin ---
-    function handleFocusIn(e) {
-        const target = e.target;
-        const blockEl = target.closest('.md-block--editable');
-        if (!blockEl)
-            return;
-        if (blockEl !== activeBlockEl) {
-            // Switching blocks — commit the previous one
-            if (activeBlockEl && activeEditEl) {
-                void commitBlock(activeBlockEl, activeEditEl);
-            }
-            activeBlockEl = blockEl;
-            activeEditEl = getEditableChild(blockEl);
-        }
-    }
-    // --- Commit when focus leaves the editor entirely ---
-    function handleFocusOut(e) {
-        const related = e.relatedTarget;
-        // Focus stayed inside the editor or toolbar — don't commit
-        if (related && (container.contains(related) || toolbar.element.contains(related)))
-            return;
-        toolbar.hide();
-        if (activeBlockEl && activeEditEl) {
-            void commitBlock(activeBlockEl, activeEditEl);
-        }
-        activeBlockEl = null;
-        activeEditEl = null;
-    }
-    // --- Keyboard shortcuts ---
-    function handleKeydown(e) {
-        if (!activeBlockEl || !activeEditEl)
-            return;
-        if (handleFormatKeydown(e))
-            return;
-        // Enter in headings → commit
-        if (e.key === 'Enter' && activeBlockEl.dataset.mdType === 'heading') {
-            e.preventDefault();
-            toolbar.hide();
-            void commitBlock(activeBlockEl, activeEditEl);
-            activeBlockEl = null;
-            activeEditEl = null;
-            return;
-        }
-        // Escape → revert this block
-        if (e.key === 'Escape') {
-            e.preventDefault();
-            toolbar.hide();
-            const key = blockKey(activeBlockEl);
-            const origHTML = originalHTML.get(key);
-            if (origHTML !== undefined && activeEditEl) {
-                activeEditEl.innerHTML = origHTML;
-            }
-            activeEditEl?.blur();
-            activeBlockEl = null;
-            activeEditEl = null;
-        }
-    }
-    // --- Toolbar: show on any text selection in any editable block ---
-    function handleSelectionChange() {
-        const sel = document.getSelection();
-        if (!sel || !sel.rangeCount)
-            return;
-        if (sel.isCollapsed) {
-            // Keep toolbar visible if a dropdown is open (user is picking
-            // a color/size), otherwise hide it.
-            if (toolbar.isVisible && !toolbar.hasOpenDropdown) {
-                toolbar.hide();
-            }
-            return;
-        }
-        // Check if the selection is within any editable block in this editor
-        const anchor = sel.anchorNode;
-        const focus = sel.focusNode;
-        if (!anchor || !focus)
-            return;
-        if (!container.contains(anchor) || !container.contains(focus))
-            return;
-        const editEl = anchor.parentElement?.closest('[contenteditable="true"]');
-        if (!editEl || !container.contains(editEl))
-            return;
-        const range = sel.getRangeAt(0);
-        const selRect = range.getBoundingClientRect();
-        const containerRect = container.getBoundingClientRect();
-        toolbar.show(selRect, containerRect);
-    }
-    container.addEventListener('focusin', handleFocusIn);
-    container.addEventListener('focusout', handleFocusOut);
-    container.addEventListener('keydown', handleKeydown);
-    document.addEventListener('selectionchange', handleSelectionChange);
-    return {
-        cleanup() {
-            container.removeEventListener('focusin', handleFocusIn);
-            container.removeEventListener('focusout', handleFocusOut);
-            container.removeEventListener('keydown', handleKeydown);
-            document.removeEventListener('selectionchange', handleSelectionChange);
-            toolbar.destroy();
-        },
-        isEditing() {
-            return activeEditEl !== null;
-        },
-    };
-}

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

@@ -1,25 +0,0 @@
-export interface Block {
-    start: number;
-    end: number;
-    text: string;
-}
-/**
- * Split markdown source into top-level blocks with source ranges. The ranges
- * drive byte-exact preservation of untouched content when merging Milkdown's
- * re-serialized output back into the original on-disk source.
- */
-export declare function extractBlocks(source: string): Block[];
-export interface MergeReport {
-    merged: string;
-    preservedCount: number;
-    rewrittenCount: number;
-    /** Populated when block counts don't align and we fell back to the full output. */
-    fallback?: string;
-}
-/**
- * Merge Milkdown's current serialization back into the original on-disk source
- * block-by-block. Blocks whose Milkdown representation is unchanged since mount
- * are emitted byte-identical to disk; edited blocks take Milkdown's output.
- * Separators between blocks come from the original source.
- */
-export declare function mergeBlocks(originalSource: string, originalBlocks: Block[], baselineBlocks: Block[], currentSerialization: string, currentBlocks: Block[]): MergeReport;

package/dist/ui/file-preview/src/markdown/block-merge.js

@@ -1,86 +0,0 @@
-// markdown-it ships without TypeScript typings in this setup; reuse the
-// existing ambient-import pattern from parser.ts.
-// @ts-expect-error markdown-it does not provide local TypeScript typings in this setup.
-import MarkdownIt from 'markdown-it';
-const parser = new MarkdownIt({ html: true });
-/**
- * Split markdown source into top-level blocks with source ranges. The ranges
- * drive byte-exact preservation of untouched content when merging Milkdown's
- * re-serialized output back into the original on-disk source.
- */
-export function extractBlocks(source) {
-    const tokens = parser.parse(source, {});
-    const lines = source.split('\n');
-    const lineOffsets = [0];
-    for (let i = 0; i < lines.length; i++) {
-        lineOffsets.push(lineOffsets[i] + lines[i].length + 1);
-    }
-    const blocks = [];
-    let lastEndLine = 0;
-    for (const token of tokens) {
-        if (!token.map || token.map.length < 2)
-            continue;
-        const [startLine, endLine] = token.map;
-        const t = token.type;
-        const isOpening = typeof t === 'string' && (t.endsWith('_open')
-            || t === 'hr'
-            || t === 'fence'
-            || t === 'code_block'
-            || t === 'html_block');
-        if (!isOpening || startLine < lastEndLine)
-            continue;
-        const start = lineOffsets[startLine];
-        const rawEnd = lineOffsets[endLine] ?? source.length;
-        const end = Math.min(source.length, Math.max(start, rawEnd - 1));
-        blocks.push({ start, end, text: source.slice(start, end) });
-        lastEndLine = endLine;
-    }
-    return blocks;
-}
-/**
- * Merge Milkdown's current serialization back into the original on-disk source
- * block-by-block. Blocks whose Milkdown representation is unchanged since mount
- * are emitted byte-identical to disk; edited blocks take Milkdown's output.
- * Separators between blocks come from the original source.
- */
-export function mergeBlocks(originalSource, originalBlocks, baselineBlocks, currentSerialization, currentBlocks) {
-    if (originalBlocks.length !== baselineBlocks.length) {
-        return {
-            merged: currentSerialization,
-            preservedCount: 0,
-            rewrittenCount: currentBlocks.length,
-            fallback: `original parses to ${originalBlocks.length} blocks but baseline parses to ${baselineBlocks.length}`,
-        };
-    }
-    if (baselineBlocks.length !== currentBlocks.length) {
-        return {
-            merged: currentSerialization,
-            preservedCount: 0,
-            rewrittenCount: currentBlocks.length,
-            fallback: `block count changed (baseline=${baselineBlocks.length}, current=${currentBlocks.length})`,
-        };
-    }
-    const parts = [];
-    let preserved = 0;
-    let rewritten = 0;
-    parts.push(originalSource.slice(0, originalBlocks[0]?.start ?? 0));
-    for (let i = 0; i < originalBlocks.length; i++) {
-        if (baselineBlocks[i].text === currentBlocks[i].text) {
-            parts.push(originalBlocks[i].text);
-            preserved++;
-        }
-        else {
-            parts.push(currentBlocks[i].text);
-            rewritten++;
-        }
-        const nextStart = i + 1 < originalBlocks.length
-            ? originalBlocks[i + 1].start
-            : originalSource.length;
-        parts.push(originalSource.slice(originalBlocks[i].end, nextStart));
-    }
-    return {
-        merged: parts.join(''),
-        preservedCount: preserved,
-        rewrittenCount: rewritten,
-    };
-}

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

@@ -1,13 +0,0 @@
-import type { MarkdownLinkHeading, MarkdownLinkSearchItem } from './editor.js';
-export declare function renderLinkModalHtml(): string;
-export interface LinkModalHandle {
-    open(selectedText?: string): void;
-    close(): void;
-    destroy(): void;
-}
-export declare function attachLinkModal(options: {
-    root: HTMLElement;
-    searchLinks?: (query: string) => Promise<MarkdownLinkSearchItem[]>;
-    loadHeadings?: (filePath: string) => Promise<MarkdownLinkHeading[]>;
-    onInsert: (text: string) => void;
-}): LinkModalHandle;