@wonderwhy-er/desktop-commander 0.2.38 → 0.2.40

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

@@ -0,0 +1,16 @@
+export interface ResolvedMarkdownLink {
+    kind: 'external' | 'anchor' | 'file';
+    href: string;
+    url?: string;
+    targetPath?: string;
+    anchor?: string;
+}
+/**
+ * Invert `rewriteWikiLinks`: convert `[alias](href "mcp-wiki:ENCODED")` links
+ * back to their original `[[...]]` form. Used when serializing a WYSIWYG
+ * edit session back to markdown — the `mcp-wiki:` title prefix is the
+ * round-trip marker written by `rewriteWikiLinks`.
+ */
+export declare function restoreWikiLinks(markdown: string): string;
+export declare function rewriteWikiLinks(source: string): string;
+export declare function resolveMarkdownLink(currentPath: string, rawHref: string): ResolvedMarkdownLink;

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

@@ -0,0 +1,228 @@
+import { slugifyMarkdownHeading } from './slugify.js';
+import { getParentDirectory, isWindowsAbsolutePath, normalizeFilePath, normalizePathSeparators } from '../path-utils.js';
+const WIKI_LINK_PATTERN = /\[\[([^\]|#]*)(?:#([^\]|]+))?(?:\|([^\]]+))?\]\]/g;
+const FENCE_PATTERN = /^(`{3,}|~{3,})/;
+function encodeLinkPath(pathValue) {
+    return encodeURI(normalizePathSeparators(pathValue));
+}
+function safeDecodeURIComponent(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+function parseWikiLink(rawHref) {
+    const match = rawHref.match(/^\[\[([^\]|#]*)(?:#([^\]|]+))?(?:\|([^\]]+))?\]\]$/);
+    if (!match) {
+        return null;
+    }
+    return {
+        path: (match[1] ?? '').trim(),
+        anchor: match[2]?.trim(),
+        alias: match[3]?.trim(),
+    };
+}
+function buildWikiDisplayText(link) {
+    if (link.alias && link.alias.length > 0) {
+        return link.alias;
+    }
+    if (link.path && link.anchor) {
+        return `${link.path}#${link.anchor}`;
+    }
+    if (link.path) {
+        return link.path;
+    }
+    return link.anchor ?? '';
+}
+function appendMarkdownExtension(pathValue) {
+    if (/\.[A-Za-z0-9_-]+$/.test(pathValue)) {
+        return pathValue;
+    }
+    return `${pathValue}.md`;
+}
+function buildWikiHref(link) {
+    if (!link.path) {
+        if (!link.anchor) {
+            return '#';
+        }
+        return `#${slugifyMarkdownHeading(link.anchor)}`;
+    }
+    const normalizedPath = appendMarkdownExtension(normalizePathSeparators(link.path));
+    const prefixedPath = normalizedPath.startsWith('./')
+        || normalizedPath.startsWith('../')
+        || normalizedPath.startsWith('/')
+        || isWindowsAbsolutePath(normalizedPath)
+        ? normalizedPath
+        : `./${normalizedPath}`;
+    const encodedPath = encodeLinkPath(prefixedPath);
+    if (!link.anchor) {
+        return encodedPath;
+    }
+    return `${encodedPath}#${slugifyMarkdownHeading(link.anchor)}`;
+}
+function rewriteWikiLinksInPlainText(segment) {
+    return segment.replace(WIKI_LINK_PATTERN, (match) => {
+        const parsed = parseWikiLink(match);
+        if (!parsed) {
+            return match;
+        }
+        const displayText = buildWikiDisplayText(parsed);
+        const href = buildWikiHref(parsed);
+        return `[${displayText}](${href} "mcp-wiki:${encodeURIComponent(match)}")`;
+    });
+}
+function replaceWikiLinksOutsideInlineCode(line) {
+    let result = '';
+    let cursor = 0;
+    while (cursor < line.length) {
+        const codeStart = line.indexOf('`', cursor);
+        if (codeStart === -1) {
+            result += rewriteWikiLinksInPlainText(line.slice(cursor));
+            break;
+        }
+        result += rewriteWikiLinksInPlainText(line.slice(cursor, codeStart));
+        let delimiterEnd = codeStart;
+        while (delimiterEnd < line.length && line[delimiterEnd] === '`') {
+            delimiterEnd += 1;
+        }
+        const delimiter = line.slice(codeStart, delimiterEnd);
+        const codeEnd = line.indexOf(delimiter, delimiterEnd);
+        if (codeEnd === -1) {
+            result += line.slice(codeStart);
+            break;
+        }
+        result += line.slice(codeStart, codeEnd + delimiter.length);
+        cursor = codeEnd + delimiter.length;
+    }
+    return result;
+}
+function decodeAnchorFragment(fragment) {
+    if (!fragment || fragment.length === 0) {
+        return undefined;
+    }
+    return safeDecodeURIComponent(fragment);
+}
+function splitHref(rawHref) {
+    const hashIndex = rawHref.indexOf('#');
+    if (hashIndex === -1) {
+        return { pathPart: rawHref };
+    }
+    return {
+        pathPart: rawHref.slice(0, hashIndex),
+        anchorPart: rawHref.slice(hashIndex + 1),
+    };
+}
+function toDirectoryFileUrl(directoryPath) {
+    const normalized = normalizeFilePath(directoryPath);
+    const withTrailingSlash = normalized.endsWith('/') ? normalized : `${normalized}/`;
+    if (isWindowsAbsolutePath(withTrailingSlash)) {
+        return new URL(`file:///${encodeLinkPath(withTrailingSlash)}`);
+    }
+    if (withTrailingSlash.startsWith('/')) {
+        return new URL(`file://${encodeLinkPath(withTrailingSlash)}`);
+    }
+    return new URL(`file:///${encodeLinkPath(withTrailingSlash)}`);
+}
+function fromFileUrl(url) {
+    const decodedPath = safeDecodeURIComponent(url.pathname);
+    if (/^\/[A-Za-z]:\//.test(decodedPath)) {
+        return decodedPath.slice(1);
+    }
+    return decodedPath;
+}
+function isExternalHref(rawHref) {
+    return /^[A-Za-z][A-Za-z0-9+.-]*:/.test(rawHref) && !isWindowsAbsolutePath(rawHref);
+}
+function resolveFileTargetPath(currentPath, rawPath) {
+    const normalizedRawPath = normalizePathSeparators(safeDecodeURIComponent(rawPath));
+    if (normalizedRawPath.startsWith('/') || isWindowsAbsolutePath(normalizedRawPath)) {
+        return normalizeFilePath(normalizedRawPath);
+    }
+    const baseDirectory = getParentDirectory(currentPath);
+    if (baseDirectory === '.' && !normalizeFilePath(currentPath).includes('/')) {
+        return normalizeFilePath(normalizedRawPath);
+    }
+    const resolvedUrl = new URL(encodeURI(normalizedRawPath), toDirectoryFileUrl(baseDirectory));
+    return normalizeFilePath(fromFileUrl(resolvedUrl));
+}
+/**
+ * Invert `rewriteWikiLinks`: convert `[alias](href "mcp-wiki:ENCODED")` links
+ * back to their original `[[...]]` form. Used when serializing a WYSIWYG
+ * edit session back to markdown — the `mcp-wiki:` title prefix is the
+ * round-trip marker written by `rewriteWikiLinks`.
+ */
+export function restoreWikiLinks(markdown) {
+    return markdown.replace(/\[([^\]]*)\]\(([^)\s]*)(?:\s+"mcp-wiki:([^"]+)")\)/g, (_, _alias, _href, encoded) => {
+        try {
+            return decodeURIComponent(encoded);
+        }
+        catch {
+            return `[[${encoded}]]`;
+        }
+    });
+}
+export function rewriteWikiLinks(source) {
+    const lines = source.split('\n');
+    let activeFence = null;
+    return lines.map((line) => {
+        const trimmedStart = line.trimStart();
+        const fenceMatch = trimmedStart.match(FENCE_PATTERN);
+        if (fenceMatch) {
+            const marker = fenceMatch[1];
+            if (!activeFence) {
+                activeFence = marker;
+            }
+            else if (marker[0] === activeFence[0] && marker.length >= activeFence.length) {
+                activeFence = null;
+            }
+            return line;
+        }
+        if (activeFence) {
+            return line;
+        }
+        return replaceWikiLinksOutsideInlineCode(line);
+    }).join('\n');
+}
+export function resolveMarkdownLink(currentPath, rawHref) {
+    const wikiLink = parseWikiLink(rawHref);
+    if (wikiLink) {
+        const href = buildWikiHref(wikiLink);
+        if (href.startsWith('#')) {
+            return {
+                kind: 'anchor',
+                href: rawHref,
+                anchor: decodeAnchorFragment(href.slice(1)),
+            };
+        }
+        const [pathPart, anchorPart] = href.split('#');
+        return {
+            kind: 'file',
+            href: rawHref,
+            targetPath: resolveFileTargetPath(currentPath, pathPart),
+            ...(anchorPart ? { anchor: decodeAnchorFragment(anchorPart) } : {}),
+        };
+    }
+    if (isExternalHref(rawHref)) {
+        return {
+            kind: 'external',
+            href: rawHref,
+            url: rawHref,
+        };
+    }
+    if (rawHref.startsWith('#')) {
+        return {
+            kind: 'anchor',
+            href: rawHref,
+            anchor: decodeAnchorFragment(rawHref.slice(1)),
+        };
+    }
+    const { pathPart, anchorPart } = splitHref(rawHref);
+    return {
+        kind: 'file',
+        href: rawHref,
+        targetPath: resolveFileTargetPath(currentPath, pathPart),
+        ...(anchorPart ? { anchor: decodeAnchorFragment(anchorPart) } : {}),
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { DocumentOutlineItem } from '../document-outline.js';
+export declare function extractMarkdownOutline(source: string): DocumentOutlineItem[];

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

@@ -0,0 +1,16 @@
+import { createMarkdownIt, prepareMarkdownSource, readHeadingProjection } from './parser.js';
+import { createSlugTracker } from './slugify.js';
+const outlineParser = createMarkdownIt();
+export function extractMarkdownOutline(source) {
+    const tokens = outlineParser.parse(prepareMarkdownSource(source), {});
+    const nextSlug = createSlugTracker();
+    const outline = [];
+    for (let index = 0; index < tokens.length; index += 1) {
+        const heading = readHeadingProjection(tokens, index, nextSlug);
+        if (!heading) {
+            continue;
+        }
+        outline.push(heading);
+    }
+    return outline;
+}

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

@@ -0,0 +1,30 @@
+import type { MarkdownSlugTracker } from './slugify.js';
+export interface MarkdownToken {
+    type?: string;
+    tag?: string;
+    map?: number[];
+    children?: unknown;
+    content?: unknown;
+    attrSet?: (name: string, value: string) => void;
+    attrGet?: (name: string) => string | null;
+    attrs?: Array<[string, string]>;
+}
+interface MarkdownItInstance {
+    render: (source: string, env?: Record<string, unknown>) => string;
+    parse: (source: string, env?: Record<string, unknown>) => MarkdownToken[];
+    renderer: {
+        rules: Record<string, (...args: unknown[]) => string>;
+    };
+}
+export interface MarkdownHeadingProjection {
+    id: string;
+    text: string;
+    level: number;
+    line: number;
+}
+export declare function createMarkdownIt(options?: {
+    highlight?: (code: string, language: string) => string;
+}): MarkdownItInstance;
+export declare function prepareMarkdownSource(source: string): string;
+export declare function readHeadingProjection(tokens: MarkdownToken[], index: number, nextSlug: MarkdownSlugTracker): MarkdownHeadingProjection | null;
+export {};

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

@@ -0,0 +1,38 @@
+// markdown-it is intentionally typed locally here to avoid maintaining ambient module declarations.
+import MarkdownIt from 'markdown-it';
+import { rewriteWikiLinks } from './linking.js';
+import { extractInlineText } from './utils.js';
+const MarkdownItCtor = MarkdownIt;
+export function createMarkdownIt(options = {}) {
+    return new MarkdownItCtor({
+        html: false,
+        linkify: true,
+        typographer: false,
+        ...(options.highlight ? { highlight: options.highlight } : {}),
+    });
+}
+export function prepareMarkdownSource(source) {
+    return rewriteWikiLinks(source);
+}
+export function readHeadingProjection(tokens, index, nextSlug) {
+    const token = tokens[index];
+    if (token?.type !== 'heading_open' || typeof token.tag !== 'string') {
+        return null;
+    }
+    const level = Number.parseInt(token.tag.replace(/^h/i, ''), 10);
+    if (!Number.isFinite(level)) {
+        return null;
+    }
+    const inlineToken = tokens[index + 1];
+    const text = extractInlineText(inlineToken).trim();
+    if (!text) {
+        return null;
+    }
+    const lineMap = Array.isArray(token.map) ? token.map : undefined;
+    return {
+        id: nextSlug(text),
+        text,
+        level,
+        line: typeof lineMap?.[0] === 'number' ? lineMap[0] + 1 : index + 1,
+    };
+}

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

@@ -0,0 +1 @@
+export declare function getRenderedMarkdownCopyText(content: string): string;

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

@@ -0,0 +1,20 @@
+import { renderMarkdown } from '../components/markdown-renderer.js';
+export function getRenderedMarkdownCopyText(content) {
+    const html = renderMarkdown(content);
+    const normalizedHtml = html
+        .replace(/<\s*br\s*\/?>/gi, '\n')
+        .replace(/<\/p>/gi, '\n\n')
+        .replace(/<\/h[1-6]>/gi, '\n\n')
+        .replace(/<\/li>/gi, '\n')
+        .replace(/<li>/gi, '- ')
+        .replace(/<[^>]+>/g, '');
+    return normalizedHtml
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&#39;/g, "'")
+        .replace(/&quot;/g, '"')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}

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

@@ -0,0 +1,3 @@
+export type MarkdownSlugTracker = (text: string) => string;
+export declare function slugifyMarkdownHeading(text: string): string;
+export declare function createSlugTracker(): MarkdownSlugTracker;

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

@@ -0,0 +1,31 @@
+function sanitizeSlugPart(text) {
+    const normalized = text
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9\s-]/g, ' ')
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return normalized.length > 0 ? normalized : 'section';
+}
+export function slugifyMarkdownHeading(text) {
+    return sanitizeSlugPart(text);
+}
+export function createSlugTracker() {
+    const counts = new Map();
+    const usedSlugs = new Set();
+    return (text) => {
+        const baseSlug = slugifyMarkdownHeading(text);
+        let nextCount = counts.get(baseSlug) ?? 1;
+        let nextSlug = nextCount === 1 ? baseSlug : `${baseSlug}-${nextCount}`;
+        while (usedSlugs.has(nextSlug)) {
+            nextCount += 1;
+            nextSlug = `${baseSlug}-${nextCount}`;
+        }
+        counts.set(baseSlug, nextCount + 1);
+        usedSlugs.add(nextSlug);
+        return nextSlug;
+    };
+}

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

@@ -0,0 +1 @@
+export declare function extractInlineText(token: Record<string, unknown> | undefined): string;

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

@@ -0,0 +1,15 @@
+export function extractInlineText(token) {
+    if (!token) {
+        return '';
+    }
+    const children = Array.isArray(token.children) ? token.children : [];
+    if (children.length === 0) {
+        return typeof token.content === 'string' ? token.content : '';
+    }
+    return children.map((child) => {
+        if (typeof child.content === 'string') {
+            return child.content;
+        }
+        return '';
+    }).join('');
+}

package/dist/ui/file-preview/src/model.d.ts

@@ -0,0 +1,35 @@
+import type { DocumentOutlineItem } from './document-outline.js';
+import type { FilePreviewStructuredContent } from '../../../types.js';
+import type { MarkdownEditRange, MarkdownEditorView } from './markdown/editor.js';
+export type RenderPayload = FilePreviewStructuredContent & {
+    content: string;
+};
+export interface MarkdownWorkspaceState {
+    filePath: string;
+    sourceContent: string;
+    fullDocumentContent: string;
+    draftContent: string;
+    outline: DocumentOutlineItem[];
+    mode: 'edit';
+    dirty: boolean;
+    dirtyLineRanges: MarkdownEditRange[];
+    activeHeadingId: string | null;
+    pendingAnchor: string | null;
+    notice: string | null;
+    error: string | null;
+    saving: boolean;
+    loadingDocument: boolean;
+    editorView: MarkdownEditorView;
+    editorScrollTop: number;
+    saveIndicator: 'idle' | 'saving' | 'saved';
+    fileDeleted: boolean;
+}
+export interface RenderBodyResult {
+    html: string;
+    notice?: string;
+}
+export interface FileTypeCapabilities {
+    supportsPreview: boolean;
+    canCopy: boolean;
+    canOpenInFolder: boolean;
+}

package/dist/ui/file-preview/src/panel-actions.d.ts

@@ -0,0 +1,17 @@
+import type { RenderPayload } from './model.js';
+import type { MarkdownController } from './markdown/controller.js';
+import type { HtmlPreviewMode } from './types.js';
+export declare function attachPanelActions(options: {
+    container: HTMLElement;
+    payload: RenderPayload;
+    htmlMode: HtmlPreviewMode;
+    getIsExpanded: () => boolean;
+    callTool?: (name: string, args: Record<string, unknown>) => Promise<unknown | undefined>;
+    trackUiEvent?: (event: string, params?: Record<string, unknown>) => void;
+    getFileExtensionForAnalytics: (filePath: string) => string;
+    buildOpenInFolderCommand: (filePath: string) => string | undefined;
+    buildOpenInEditorCommand: (filePath: string) => string | undefined;
+    render: (payload?: RenderPayload, htmlMode?: HtmlPreviewMode, expandedState?: boolean) => void;
+    updateSaveStatus: (label: string, statusClass: string) => void;
+    markdownController: MarkdownController;
+}): void;

package/dist/ui/file-preview/src/panel-actions.js

@@ -0,0 +1,182 @@
+import { parseReadRange, stripReadStatusLine } from './document-workspace.js';
+import { extractToolText } from './payload-utils.js';
+export function attachPanelActions(options) {
+    const queryById = (id) => (options.container.querySelector(`#${id}`));
+    const fallbackCopy = (text) => {
+        const textArea = document.createElement('textarea');
+        textArea.value = text;
+        textArea.setAttribute('readonly', '');
+        textArea.style.position = 'fixed';
+        textArea.style.top = '-9999px';
+        document.body.appendChild(textArea);
+        textArea.select();
+        const success = document.execCommand('copy');
+        document.body.removeChild(textArea);
+        return success;
+    };
+    const setButtonState = (button, label, fallbackLabel, revertMs) => {
+        button.setAttribute('title', label);
+        button.setAttribute('aria-label', label);
+        button.textContent = label;
+        if (revertMs) {
+            setTimeout(() => {
+                button.textContent = fallbackLabel;
+                button.setAttribute('title', fallbackLabel);
+                button.setAttribute('aria-label', fallbackLabel);
+            }, revertMs);
+        }
+    };
+    const setIconButtonState = (button, label, fallbackLabel, revertMs) => {
+        button.setAttribute('title', label);
+        button.setAttribute('aria-label', label);
+        button.dataset.status = label;
+        if (revertMs) {
+            setTimeout(() => {
+                button.setAttribute('title', fallbackLabel);
+                button.setAttribute('aria-label', fallbackLabel);
+                delete button.dataset.status;
+            }, revertMs);
+        }
+    };
+    const copyTextData = async (text) => {
+        try {
+            if (navigator.clipboard?.writeText) {
+                await navigator.clipboard.writeText(text);
+                return true;
+            }
+            return fallbackCopy(text);
+        }
+        catch {
+            return fallbackCopy(text);
+        }
+    };
+    const fileExtension = options.getFileExtensionForAnalytics(options.payload.filePath);
+    const copyButton = queryById('copy-source');
+    copyButton?.addEventListener('click', async () => {
+        options.trackUiEvent?.('copy_clicked', {
+            file_type: options.payload.fileType,
+            file_extension: fileExtension,
+        });
+        const copied = await copyTextData(stripReadStatusLine(options.payload.content));
+        setButtonState(copyButton, copied ? 'Copied!' : 'Copy failed', 'Copy', 1500);
+    });
+    const activeCopyButton = queryById('copy-active-markdown');
+    activeCopyButton?.addEventListener('click', async () => {
+        const textToCopy = options.markdownController.getCopyText(options.payload);
+        if (!textToCopy) {
+            return;
+        }
+        const copied = await copyTextData(textToCopy);
+        if (copied) {
+            options.updateSaveStatus('Copied', 'saved');
+            window.setTimeout(() => options.updateSaveStatus('', ''), 1500);
+        }
+        setIconButtonState(activeCopyButton, copied ? 'Copied!' : 'Copy failed', 'Copy', 1500);
+    });
+    const toggleButton = queryById('toggle-html-mode');
+    toggleButton?.addEventListener('click', () => {
+        const nextMode = options.htmlMode === 'rendered' ? 'source' : 'rendered';
+        options.trackUiEvent?.('html_view_toggled', {
+            file_type: options.payload.fileType,
+            file_extension: fileExtension,
+        });
+        options.render(options.payload, nextMode, options.getIsExpanded());
+    });
+    const openFolderButton = queryById('open-in-folder');
+    if (openFolderButton) {
+        const command = options.buildOpenInFolderCommand(options.payload.filePath);
+        if (!command) {
+            openFolderButton.disabled = true;
+        }
+        else {
+            openFolderButton.addEventListener('click', async () => {
+                options.trackUiEvent?.('open_in_folder', {
+                    file_type: options.payload.fileType,
+                    file_extension: fileExtension,
+                });
+                try {
+                    await options.callTool?.('start_process', { command, timeout_ms: 12000 });
+                }
+                catch {
+                    // Keep UI stable if opening folder fails.
+                }
+            });
+        }
+    }
+    const openEditorButton = queryById('open-in-editor');
+    if (openEditorButton) {
+        const command = options.buildOpenInEditorCommand(options.payload.filePath);
+        if (!command) {
+            openEditorButton.disabled = true;
+        }
+        else {
+            openEditorButton.addEventListener('click', async () => {
+                options.trackUiEvent?.('open_in_editor', {
+                    file_type: options.payload.fileType,
+                    file_extension: fileExtension,
+                });
+                try {
+                    await options.callTool?.('start_process', { command, timeout_ms: 12000 });
+                }
+                catch {
+                    // Keep UI stable if opening editor fails.
+                }
+            });
+        }
+    }
+    const beforeBtn = queryById('load-before');
+    const afterBtn = queryById('load-after');
+    if (!beforeBtn && !afterBtn) {
+        return;
+    }
+    const range = parseReadRange(options.payload.content);
+    if (!range?.isPartial) {
+        return;
+    }
+    const currentContent = stripReadStatusLine(options.payload.content);
+    const loadLines = async (button, direction) => {
+        const originalText = button.textContent;
+        button.textContent = 'Loading…';
+        button.disabled = true;
+        options.trackUiEvent?.(direction === 'before' ? 'load_lines_before' : 'load_lines_after', {
+            file_type: options.payload.fileType,
+            file_extension: fileExtension,
+        });
+        try {
+            const readArgs = direction === 'before'
+                ? { path: options.payload.filePath, offset: 0, length: range.fromLine - 1 }
+                : { path: options.payload.filePath, offset: range.toLine };
+            const result = await options.callTool?.('read_file', readArgs);
+            const newText = extractToolText(result);
+            if (newText && typeof newText === 'string') {
+                const cleanNew = stripReadStatusLine(newText);
+                const merged = direction === 'before'
+                    ? `${cleanNew}${cleanNew.endsWith('\n') ? '' : '\n'}${currentContent}`
+                    : `${currentContent}${currentContent.endsWith('\n') ? '' : '\n'}${cleanNew}`;
+                const newFrom = direction === 'before' ? 1 : range.fromLine;
+                const newTo = direction === 'after' ? range.totalLines : range.toLine;
+                const lineCount = newTo - newFrom + 1;
+                const remaining = range.totalLines - newTo;
+                const isStillPartial = newFrom > 1 || newTo < range.totalLines;
+                const statusLine = isStillPartial
+                    ? `[Reading ${lineCount} lines from ${newFrom === 1 ? 'start' : `line ${newFrom}`} (total: ${range.totalLines} lines, ${remaining} remaining)]\n`
+                    : '';
+                options.render({
+                    ...options.payload,
+                    content: statusLine + merged,
+                }, options.htmlMode, options.getIsExpanded());
+                return;
+            }
+        }
+        catch {
+            // Fall through to button reset.
+        }
+        button.textContent = 'Failed to load';
+        setTimeout(() => {
+            button.textContent = originalText;
+            button.disabled = false;
+        }, 2000);
+    };
+    beforeBtn?.addEventListener('click', () => void loadLines(beforeBtn, 'before'));
+    afterBtn?.addEventListener('click', () => void loadLines(afterBtn, 'after'));
+}

package/dist/ui/file-preview/src/path-utils.d.ts

@@ -0,0 +1,6 @@
+export declare function isWindowsAbsolutePath(value: string): boolean;
+export declare function normalizePathSeparators(value: string): string;
+export declare function normalizeFilePath(value: string): string;
+export declare function getParentDirectory(filePath: string): string;
+export declare function getAncestorDirectories(filePath: string): string[];
+export declare function toPosixRelativePath(fromDirectory: string, targetPath: string): string;