@wonderwhy-er/desktop-commander 0.2.38 → 0.2.40

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

@@ -0,0 +1,64 @@
+export function isWindowsAbsolutePath(value) {
+    return /^[A-Za-z]:[\\/]/.test(value);
+}
+export function normalizePathSeparators(value) {
+    return value.replace(/\\/g, '/');
+}
+export function normalizeFilePath(value) {
+    const normalized = normalizePathSeparators(value);
+    return normalized.replace(/\/+/g, '/');
+}
+function getPathRoot(value) {
+    const normalized = normalizeFilePath(value);
+    if (isWindowsAbsolutePath(normalized)) {
+        return normalized.slice(0, 3);
+    }
+    return normalized.startsWith('/') ? '/' : '';
+}
+function getPathSegments(value) {
+    const normalized = normalizeFilePath(value);
+    const root = getPathRoot(normalized);
+    return normalized.slice(root.length).split('/').filter(Boolean);
+}
+export function getParentDirectory(filePath) {
+    const root = getPathRoot(filePath);
+    const segments = getPathSegments(filePath);
+    if (segments.length <= 1) {
+        return root || '.';
+    }
+    return `${root}${segments.slice(0, -1).join('/')}`;
+}
+export function getAncestorDirectories(filePath) {
+    const root = getPathRoot(filePath);
+    const segments = getPathSegments(filePath);
+    const ancestors = [];
+    for (let index = segments.length - 1; index >= 1; index -= 1) {
+        const ancestor = `${root}${segments.slice(0, index).join('/')}`;
+        ancestors.push(ancestor || '.');
+    }
+    if (root && ancestors[ancestors.length - 1] !== root) {
+        ancestors.push(root);
+    }
+    return ancestors;
+}
+export function toPosixRelativePath(fromDirectory, targetPath) {
+    const normalizedFrom = normalizeFilePath(fromDirectory);
+    const normalizedTarget = normalizeFilePath(targetPath);
+    const fromRoot = getPathRoot(normalizedFrom);
+    const targetRoot = getPathRoot(normalizedTarget);
+    if (fromRoot !== targetRoot) {
+        return normalizedTarget;
+    }
+    const fromParts = getPathSegments(normalizedFrom);
+    const targetParts = getPathSegments(normalizedTarget);
+    let shared = 0;
+    while (shared < fromParts.length
+        && shared < targetParts.length
+        && fromParts[shared] === targetParts[shared]) {
+        shared += 1;
+    }
+    const up = new Array(Math.max(fromParts.length - shared, 0)).fill('..');
+    const down = targetParts.slice(shared);
+    const joined = [...up, ...down].join('/');
+    return joined.length > 0 ? joined : '.';
+}

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

@@ -0,0 +1,11 @@
+import type { FilePreviewStructuredContent } from '../../../types.js';
+import type { RenderPayload } from './model.js';
+export declare function getFileExtensionForAnalytics(filePath: string): string;
+export declare function isPreviewStructuredContent(value: unknown): value is FilePreviewStructuredContent;
+export declare function buildRenderPayload(meta: FilePreviewStructuredContent, text: string): RenderPayload;
+export declare function extractToolText(value: unknown): string | undefined;
+export declare function extractRenderPayload(value: unknown): RenderPayload | undefined;
+export declare function assertSuccessfulEditBlockResult(result: unknown): void;
+export declare function isLikelyUrl(filePath: string): boolean;
+export declare function buildBreadcrumb(filePath: string): string;
+export declare function countContentLines(content: string): number;

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

@@ -0,0 +1,94 @@
+import { escapeHtml } from './components/highlighting.js';
+import { stripReadStatusLine } from './document-workspace.js';
+function isObjectRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+export function getFileExtensionForAnalytics(filePath) {
+    const normalizedPath = filePath.trim().replace(/\\/g, '/');
+    const fileName = normalizedPath.split('/').pop() ?? normalizedPath;
+    const dotIndex = fileName.lastIndexOf('.');
+    if (dotIndex <= 0 || dotIndex === fileName.length - 1) {
+        return 'none';
+    }
+    return fileName.slice(dotIndex + 1).toLowerCase();
+}
+export function isPreviewStructuredContent(value) {
+    if (!isObjectRecord(value)) {
+        return false;
+    }
+    return (typeof value.fileName === 'string' &&
+        typeof value.filePath === 'string' &&
+        typeof value.fileType === 'string');
+}
+export function buildRenderPayload(meta, text) {
+    return { ...meta, content: text };
+}
+export function extractToolText(value) {
+    if (!isObjectRecord(value)) {
+        return undefined;
+    }
+    const content = value.content;
+    if (!Array.isArray(content)) {
+        return undefined;
+    }
+    for (const item of content) {
+        if (!isObjectRecord(item)) {
+            continue;
+        }
+        if (item.type === 'text' && typeof item.text === 'string' && item.text.trim().length > 0) {
+            return item.text;
+        }
+    }
+    return undefined;
+}
+export function extractRenderPayload(value) {
+    if (!isObjectRecord(value)) {
+        return undefined;
+    }
+    const meta = isPreviewStructuredContent(value.structuredContent)
+        ? value.structuredContent
+        : isPreviewStructuredContent(value)
+            ? value
+            : null;
+    if (!meta)
+        return undefined;
+    const text = extractToolText(value) ?? extractToolText(value.structuredContent) ?? '';
+    return buildRenderPayload(meta, text);
+}
+export function assertSuccessfulEditBlockResult(result) {
+    if (!isObjectRecord(result)) {
+        throw new Error('edit_block did not return a valid result.');
+    }
+    if (result.isError === true) {
+        const message = extractToolText(result) ?? '';
+        throw new Error(message || 'edit_block failed.');
+    }
+    // edit_block uses soft-failure returns (no isError flag) for cases the LLM
+    // is meant to recover from — "Search content not found", "Expected N
+    // occurrences but found M", fuzzy-match-too-close-to-ignore, etc. These
+    // look like success to a naive client. A real success always carries
+    // structuredContent (see src/tools/edit.ts — the write path attaches
+    // fileName/filePath/fileType); absence means the edit did not land.
+    // Throwing here routes soft failures through saveDocument's catch, which
+    // reloads disk, preserves the user's draft, and surfaces the server's
+    // message to the user.
+    if (!isObjectRecord(result.structuredContent)) {
+        const message = extractToolText(result) ?? '';
+        throw new Error(message || 'edit_block did not confirm success.');
+    }
+}
+export function isLikelyUrl(filePath) {
+    return /^https?:\/\//i.test(filePath);
+}
+export function buildBreadcrumb(filePath) {
+    const normalized = filePath.replace(/\\/g, '/');
+    const parts = normalized.split('/').filter(Boolean);
+    return parts.map((part) => escapeHtml(part)).join(' <span class="breadcrumb-sep">›</span> ');
+}
+export function countContentLines(content) {
+    const cleaned = stripReadStatusLine(content);
+    if (cleaned === '')
+        return 0;
+    const lines = cleaned.split('\n');
+    return lines[lines.length - 1] === '' ? lines.length - 1 : lines.length;
+}