@vibesdotdev/editor 0.0.0-stage → 1.0.0-rc.1

package/dist/svelte/tool-widgets/workspace-search-card.js

@@ -0,0 +1,428 @@
+export const WORKSPACE_SEARCH_CARD_ICON = 'lucide:file-search';
+export const WORKSPACE_SEARCH_LIST_LIMIT = 12;
+import { SearchCardInputSchema, SearchCardOutputSchema } from "../../schemas/search-card.js";
+const INDEX_ACTIONS = new Set([
+    'index-status',
+    'index-create',
+    'index-incremental',
+    'index-delete',
+    'index-list',
+    'index-update',
+    'index-alias',
+    'index-alias-set',
+    'index-alias-remove',
+    'job-status'
+]);
+function asString(value) { return value ?? ''; }
+function asNumber(value) { return value ?? null; }
+function take(items, limit = WORKSPACE_SEARCH_LIST_LIMIT) {
+    if (items.length <= limit)
+        return { items, hiddenCount: 0 };
+    return { items: items.slice(0, limit), hiddenCount: items.length - limit };
+}
+function formatScore(value) {
+    if (value === undefined)
+        return '';
+    return Number.isInteger(value) ? String(value) : value.toFixed(2);
+}
+function plural(count, noun) {
+    return `${count} ${noun}${count === 1 ? '' : 's'}`;
+}
+function locationFromParts(path, line) {
+    const lineNumber = asNumber(line);
+    if (path && lineNumber !== null)
+        return `${path}:${lineNumber}`;
+    return path;
+}
+export function workspaceSearchAction(input, output) {
+    const parsedInput = SearchCardInputSchema.safeParse(input);
+    const parsedOutput = SearchCardOutputSchema.safeParse(output);
+    return actionFrom(parsedInput.success ? parsedInput.data : null, parsedOutput.success ? parsedOutput.data : null);
+}
+function actionFrom(input, output) {
+    if (input?.action)
+        return input.action;
+    if (input?.query || output?.results)
+        return 'search';
+    if (output?.workspaceIndex)
+        return 'sync-status';
+    if (output?.diagnostics)
+        return 'diagnostics';
+    if (output?.changes)
+        return 'rename';
+    if (output?.symbol || output?.matches || output?.references)
+        return 'symbol';
+    if (output?.nodes || output?.edges || output?.cycles || output?.path)
+        return 'graph';
+    if (output?.indexes || output?.aliases || output?.jobs || output?.job || output?.exists !== undefined || output?.indexJobId || output?.jobId)
+        return 'index-status';
+    return '';
+}
+function iconForAction(action) {
+    if (action === 'graph')
+        return 'lucide:share-2';
+    if (action === 'symbol')
+        return 'lucide:braces';
+    if (action === 'rename')
+        return 'lucide:pencil';
+    if (action === 'diagnostics')
+        return 'lucide:circle-alert';
+    if (action === 'sync-status')
+        return 'lucide:refresh-cw';
+    if (INDEX_ACTIONS.has(action))
+        return 'lucide:database';
+    return WORKSPACE_SEARCH_CARD_ICON;
+}
+function titleForAction(action, input, output) {
+    const summary = asString(output?.summary);
+    switch (action) {
+        case 'search': {
+            const query = asString(input?.query);
+            const results = Array.isArray(output?.results) ? output.results.length : null;
+            if (query && results !== null)
+                return `${plural(results, 'result')} for ${query}`;
+            if (query)
+                return `Search ${query}`;
+            return 'Code search';
+        }
+        case 'graph':
+            return summary || `Graph ${asString(input?.queryType) || 'query'}`;
+        case 'symbol': {
+            const name = asString(output?.symbol?.name) || asString(input?.symbolName) || 'Symbol';
+            return name;
+        }
+        case 'rename': {
+            const newName = asString(input?.newName);
+            const changes = Array.isArray(output?.changes) ? output.changes.length : null;
+            if (newName && changes !== null)
+                return `Rename to ${newName} (${plural(changes, 'file')})`;
+            if (newName)
+                return `Rename to ${newName}`;
+            return 'Rename';
+        }
+        case 'diagnostics': {
+            const count = asNumber(output?.count);
+            if (count !== null)
+                return plural(count, 'diagnostic');
+            return summary || 'Diagnostics';
+        }
+        case 'sync-status':
+            return 'Workspace sync';
+        case 'index-create':
+            return summary || 'Create index';
+        case 'index-incremental':
+            return summary || 'Update index';
+        case 'index-delete':
+            return summary || 'Delete index';
+        case 'index-list':
+            return summary || 'Indexes';
+        case 'index-update':
+            return summary || 'Configure index';
+        case 'index-alias-set':
+            return summary || 'Set index alias';
+        case 'index-alias-remove':
+            return summary || 'Remove index alias';
+        case 'index-alias':
+            return summary || 'Index aliases';
+        case 'job-status':
+            return summary || 'Index job';
+        case 'index-status':
+            return summary || 'Index status';
+        default:
+            return summary || 'Code search';
+    }
+}
+function parseSearchHits(output) {
+    const raw = output?.results;
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .map((row) => {
+        const item = row;
+        const content = asString(item?.content);
+        const location = asString(item?.location);
+        if (!content && !location)
+            return null;
+        return {
+            type: asString(item?.type),
+            content,
+            location,
+            score: formatScore(item?.score)
+        };
+    })
+        .filter((hit) => hit !== null);
+}
+function parseGraphNodes(output) {
+    const fromCycles = Array.isArray(output?.cycles)
+        ? output.cycles.flatMap((cycle) => (Array.isArray(cycle) ? cycle : []))
+        : [];
+    const raw = Array.isArray(output?.nodes)
+        ? output.nodes
+        : Array.isArray(output?.path)
+            ? output.path
+            : fromCycles;
+    const seen = new Set();
+    const nodes = [];
+    for (const row of raw) {
+        const item = row;
+        const id = asString(item?.id);
+        const label = asString(item?.label) || id;
+        if (!id && !label)
+            continue;
+        const key = id || label;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        nodes.push({ id: id || label, label });
+    }
+    return nodes;
+}
+function parseSymbolMatches(output) {
+    const raw = output?.matches;
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .map((row) => {
+        const item = row;
+        const name = asString(item?.name);
+        const id = asString(item?.id);
+        if (!name && !id)
+            return null;
+        return {
+            id: id || name,
+            name: name || id,
+            kind: asString(item?.kind),
+            location: locationFromParts(asString(item?.filePath), item?.startLine)
+        };
+    })
+        .filter((hit) => hit !== null);
+}
+function parseRenameChanges(output) {
+    const raw = output?.changes;
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .map((row) => {
+        const item = row;
+        const path = asString(item?.path);
+        if (!path)
+            return null;
+        return { path, diff: asString(item?.diff) };
+    })
+        .filter((hit) => hit !== null);
+}
+function parseDiagnostics(output) {
+    const raw = output?.diagnostics;
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .map((row) => {
+        const item = row;
+        const message = asString(item?.message);
+        const location = locationFromParts(asString(item?.filePath), item?.line);
+        if (!message && !location)
+            return null;
+        return {
+            severity: asString(item?.severity) || 'info',
+            location,
+            message,
+            source: asString(item?.source)
+        };
+    })
+        .filter((hit) => hit !== null);
+}
+function parseIndexRows(output) {
+    const raw = output?.indexes;
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .map((row) => {
+        const item = row;
+        const projectId = asString(item?.projectId);
+        if (!projectId)
+            return null;
+        const files = asNumber(item?.filesProcessed);
+        const symbols = asNumber(item?.symbolsCaptured);
+        return {
+            projectId,
+            configId: asString(item?.configId),
+            files: files === null ? '' : String(files),
+            symbols: symbols === null ? '' : String(symbols)
+        };
+    })
+        .filter((hit) => hit !== null);
+}
+function parseAliases(output) {
+    const raw = output?.aliases;
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .map((row) => {
+        const item = row;
+        const alias = asString(item?.alias);
+        const target = asString(item?.target);
+        if (!alias && !target)
+            return null;
+        return { alias, target };
+    })
+        .filter((hit) => hit !== null);
+}
+function parseJobs(output) {
+    const rows = [...(output?.jobs ?? [])];
+    if (output?.job)
+        rows.push(output?.job);
+    const seen = new Set();
+    const jobs = [];
+    for (const row of rows) {
+        const item = row;
+        const id = asString(item?.id) || asString(item?.jobId);
+        if (!id || seen.has(id))
+            continue;
+        seen.add(id);
+        jobs.push({
+            id,
+            status: asString(item?.status),
+            detail: asString(item?.error) || asString(item?.type)
+        });
+    }
+    return jobs;
+}
+function indexStatusLabel(output) {
+    const status = output?.indexStatus;
+    if (!status)
+        return '';
+    const runStatus = asString(status.status);
+    const files = asNumber(status.filesProcessed);
+    const symbols = asNumber(status.symbolsCaptured);
+    const parts = [runStatus];
+    if (files !== null)
+        parts.push(`${files} files`);
+    if (symbols !== null)
+        parts.push(`${symbols} symbols`);
+    return parts.filter(Boolean).join(' · ');
+}
+export function workspaceSearchCardView(tool) {
+    const parsedInput = SearchCardInputSchema.safeParse(tool.input ?? {});
+    const parsedOutput = SearchCardOutputSchema.safeParse(tool.output ?? {});
+    const input = parsedInput.success ? parsedInput.data : null;
+    const output = parsedOutput.success ? parsedOutput.data : null;
+    if (!parsedInput.success || !parsedOutput.success)
+        return { kind: 'summary', title: 'Atlas result unavailable', icon: WORKSPACE_SEARCH_CARD_ICON, summary: 'The Atlas payload is malformed.' };
+    const action = actionFrom(input, output);
+    if (tool.output != null && action === 'search' && output?.results === undefined) {
+        return {
+            kind: 'summary', title: 'Atlas result unavailable', icon: WORKSPACE_SEARCH_CARD_ICON,
+            summary: 'The Atlas search result has no results list.'
+        };
+    }
+    const title = titleForAction(action, input, output);
+    const icon = iconForAction(action);
+    if (action === 'search' || (!action && Array.isArray(output?.results))) {
+        const parsed = take(parseSearchHits(output));
+        return {
+            kind: 'search',
+            title,
+            icon,
+            query: asString(input?.query),
+            mode: asString(input?.mode),
+            warning: asString(output?.warning),
+            indexStatus: indexStatusLabel(output),
+            hits: parsed.items,
+            hiddenCount: parsed.hiddenCount
+        };
+    }
+    if (action === 'graph') {
+        const parsed = take(parseGraphNodes(output));
+        const edges = Array.isArray(output?.edges) ? output.edges.length : 0;
+        return {
+            kind: 'graph',
+            title,
+            icon,
+            summary: asString(output?.summary),
+            queryType: asString(output?.queryType) || asString(input?.queryType),
+            nodes: parsed.items,
+            edgeCount: edges,
+            hiddenCount: parsed.hiddenCount
+        };
+    }
+    if (action === 'symbol') {
+        const symbol = output?.symbol;
+        const parsed = take(parseSymbolMatches(output));
+        const references = Array.isArray(output?.references) ? output.references.length : 0;
+        return {
+            kind: 'symbol',
+            title,
+            icon,
+            summary: asString(output?.summary),
+            kindLabel: asString(symbol?.kind),
+            location: locationFromParts(asString(symbol?.filePath), symbol?.startLine),
+            signature: asString(symbol?.signature),
+            matches: parsed.items,
+            referenceCount: references,
+            hiddenCount: parsed.hiddenCount
+        };
+    }
+    if (action === 'rename') {
+        const parsed = take(parseRenameChanges(output));
+        return {
+            kind: 'rename',
+            title,
+            icon,
+            changes: parsed.items,
+            hiddenCount: parsed.hiddenCount
+        };
+    }
+    if (action === 'diagnostics') {
+        const parsed = take(parseDiagnostics(output));
+        return {
+            kind: 'diagnostics',
+            title,
+            icon,
+            summary: asString(output?.summary),
+            hits: parsed.items,
+            hiddenCount: parsed.hiddenCount
+        };
+    }
+    if (action === 'sync-status') {
+        const workspaceIndex = output?.workspaceIndex;
+        const atlas = output?.atlas;
+        const fileCount = asNumber(workspaceIndex?.fileCount);
+        const dirtyCount = asNumber(workspaceIndex?.dirtyCount);
+        return {
+            kind: 'sync-status',
+            title,
+            icon,
+            workspacePath: asString(output?.workspacePath),
+            projectId: asString(output?.projectId),
+            indexSummary: asString(workspaceIndex?.summary),
+            fileCount: fileCount === null ? '' : String(fileCount),
+            dirtyCount: dirtyCount === null ? '' : String(dirtyCount),
+            atlasSummary: asString(atlas?.summary) || (atlas?.exists === false ? 'No Atlas index' : '')
+        };
+    }
+    if (action && INDEX_ACTIONS.has(action)) {
+        const indexes = take(parseIndexRows(output));
+        const aliases = parseAliases(output);
+        const jobs = parseJobs(output);
+        const hiddenCount = indexes.hiddenCount;
+        const exists = output?.exists;
+        return {
+            kind: 'index',
+            title,
+            icon,
+            summary: asString(output?.summary),
+            projectId: asString(output?.projectId) || asString(input?.projectId),
+            exists: exists === true ? 'ready' : exists === false ? 'missing' : '',
+            indexes: indexes.items,
+            aliases,
+            jobs,
+            hiddenCount
+        };
+    }
+    return {
+        kind: 'summary',
+        title,
+        icon,
+        summary: asString(output?.summary)
+    };
+}