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

package/dist/code-atlas/tools/workspace-search.descriptor.d.ts

@@ -0,0 +1,168 @@
+export { WorkspaceSearchInputSchema, WorkspaceSearchOutputSchema } from './workspace-search.schemas.ts';
+export type { WorkspaceSearchInput, WorkspaceSearchOutput } from './workspace-search.schemas.ts';
+declare const _default: {
+    readonly kind: "tools/tool";
+    readonly id: "workspace-search";
+    readonly name: "Workspace Search";
+    readonly description: "Code atlas search and code intelligence. Actions: search (default: query + mode text|semantic|hybrid|symbol|file), graph, symbol, rename, diagnostics, index-status|create|incremental|delete|list|update|alias|alias-set|alias-remove, job-status, sync-status.";
+    readonly mcpDescription: "Semantic CODE search in this workspace (Atlas). Not a glob/grep replacement — use workspace-fs for ls/cat/find/grep. Ex: {action:\"search\",query:\"bindWorkspace\",mode:\"text\"}. Not for docs, knowledge, or web.";
+    readonly hardware: ["consumer"];
+    readonly purpose: ["direct", "mcp", "agent"];
+    readonly category: "workspace";
+    readonly subcategory: "search";
+    readonly safety: "read";
+    readonly requiresApproval: false;
+    readonly capability: {
+        readonly tier: "1";
+        readonly scopes: ["fs:read", "workspace-only"];
+    };
+    readonly tags: ["workspace", "search", "atlas", "index"];
+    readonly schemas: {
+        readonly input: import("zod").ZodObject<{
+            action: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<{
+                symbol: "symbol";
+                search: "search";
+                diagnostics: "diagnostics";
+                rename: "rename";
+                graph: "graph";
+                "index-status": "index-status";
+                "index-create": "index-create";
+                "index-incremental": "index-incremental";
+                "index-delete": "index-delete";
+                "index-list": "index-list";
+                "index-update": "index-update";
+                "index-alias": "index-alias";
+                "index-alias-set": "index-alias-set";
+                "index-alias-remove": "index-alias-remove";
+                "job-status": "job-status";
+                "sync-status": "sync-status";
+            }>>>;
+            query: import("zod").ZodOptional<import("zod").ZodString>;
+            mode: import("zod").ZodOptional<import("zod").ZodEnum<{
+                symbol: "symbol";
+                file: "file";
+                text: "text";
+                semantic: "semantic";
+                hybrid: "hybrid";
+            }>>;
+            limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+            includeContext: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            raw: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            queryType: import("zod").ZodOptional<import("zod").ZodEnum<{
+                path: "path";
+                cycles: "cycles";
+                "fan-in": "fan-in";
+                "fan-out": "fan-out";
+                "impact-radius": "impact-radius";
+            }>>;
+            nodeType: import("zod").ZodOptional<import("zod").ZodEnum<{
+                symbol: "symbol";
+                file: "file";
+                package: "package";
+            }>>;
+            packageName: import("zod").ZodOptional<import("zod").ZodString>;
+            targetPackage: import("zod").ZodOptional<import("zod").ZodString>;
+            includeDev: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            nodeId: import("zod").ZodOptional<import("zod").ZodString>;
+            sourceNodeId: import("zod").ZodOptional<import("zod").ZodString>;
+            targetNodeId: import("zod").ZodOptional<import("zod").ZodString>;
+            maxDepth: import("zod").ZodOptional<import("zod").ZodNumber>;
+            symbolId: import("zod").ZodOptional<import("zod").ZodString>;
+            symbolName: import("zod").ZodOptional<import("zod").ZodString>;
+            includeReferences: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            path: import("zod").ZodOptional<import("zod").ZodString>;
+            line: import("zod").ZodOptional<import("zod").ZodNumber>;
+            column: import("zod").ZodOptional<import("zod").ZodNumber>;
+            newName: import("zod").ZodOptional<import("zod").ZodString>;
+            dryRun: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            paths: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            excludePaths: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            languages: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+                typescript: "typescript";
+                svelte: "svelte";
+                javascript: "javascript";
+            }>>>;
+            enableEmbeddings: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            force: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            list: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+            alias: import("zod").ZodOptional<import("zod").ZodString>;
+            remove: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+            targetProjectId: import("zod").ZodOptional<import("zod").ZodString>;
+            enableLangServerEnrichment: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            enableLangServerValidation: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            triggerReindex: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            triggerIncremental: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            triggerEmbeddings: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            triggerEnrichment: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            full: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            confirm: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            filePath: import("zod").ZodOptional<import("zod").ZodString>;
+            fileId: import("zod").ZodOptional<import("zod").ZodUUID>;
+            fileMtime: import("zod").ZodOptional<import("zod").ZodNumber>;
+            source: import("zod").ZodOptional<import("zod").ZodEnum<{
+                custom: "custom";
+                bun: "bun";
+                tsc: "tsc";
+                "svelte-check": "svelte-check";
+                vite: "vite";
+                eslint: "eslint";
+                prettier: "prettier";
+                vitest: "vitest";
+            }>>;
+            severity: import("zod").ZodOptional<import("zod").ZodEnum<{
+                error: "error";
+                info: "info";
+                warning: "warning";
+                hint: "hint";
+            }>>;
+            includeStale: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            offset: import("zod").ZodOptional<import("zod").ZodNumber>;
+            jobId: import("zod").ZodOptional<import("zod").ZodString>;
+            queueName: import("zod").ZodOptional<import("zod").ZodString>;
+            status: import("zod").ZodOptional<import("zod").ZodEnum<{
+                failed: "failed";
+                pending: "pending";
+                completed: "completed";
+                processing: "processing";
+            }>>;
+            projectId: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+        readonly output: import("zod").ZodObject<{}, import("zod/v4/core").$loose>;
+        readonly defaultAction: "search";
+        readonly actionSafety: {
+            readonly search: "read";
+            readonly graph: "read";
+            readonly symbol: "read";
+            readonly diagnostics: "read";
+            readonly 'index-status': "read";
+            readonly 'index-list': "read";
+            readonly 'index-alias': "read";
+            readonly 'index-alias-set': "write";
+            readonly 'index-alias-remove': "write";
+            readonly 'job-status': "read";
+            readonly 'sync-status': "read";
+            readonly 'index-create': "write";
+            readonly 'index-incremental': "write";
+            readonly 'index-delete': "write";
+            readonly 'index-update': "write";
+            readonly rename: "write";
+        };
+    };
+    readonly examples: [{
+        readonly description: "Semantic search";
+        readonly input: {
+            readonly action: "search";
+            readonly query: "bindWorkspaceEnvironment";
+            readonly limit: 10;
+        };
+        readonly notes: "Requires atlas index on consumer";
+    }, {
+        readonly description: "Sync status";
+        readonly input: {
+            readonly action: "sync-status";
+        };
+        readonly notes: "Workspace file index + atlas state";
+    }];
+};
+export default _default;
+//# sourceMappingURL=workspace-search.descriptor.d.ts.map

package/dist/code-atlas/tools/workspace-search.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-search.descriptor.d.ts","sourceRoot":"","sources":["../../../src/code-atlas/tools/workspace-search.descriptor.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,0BAA0B,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AACxG,YAAY,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEjG,wBAqDG"}

package/dist/code-atlas/tools/workspace-search.descriptor.js

@@ -0,0 +1,56 @@
+import { createRuntimeAsset } from '@vibesdotdev/kernel/factory';
+import { WorkspaceSearchInputSchema, WorkspaceSearchOutputSchema } from "./workspace-search.schemas.js";
+export { WorkspaceSearchInputSchema, WorkspaceSearchOutputSchema } from "./workspace-search.schemas.js";
+export default createRuntimeAsset({
+    kind: 'tools/tool',
+    id: 'workspace-search',
+    name: 'Workspace Search',
+    description: 'Code atlas search and code intelligence. Actions: search (default: query + mode text|semantic|hybrid|symbol|file), graph, symbol, rename, diagnostics, index-status|create|incremental|delete|list|update|alias|alias-set|alias-remove, job-status, sync-status.',
+    mcpDescription: 'Semantic CODE search in this workspace (Atlas). Not a glob/grep replacement — use workspace-fs for ls/cat/find/grep. Ex: {action:"search",query:"bindWorkspace",mode:"text"}. Not for docs, knowledge, or web.',
+    hardware: ['consumer'],
+    purpose: ['direct', 'mcp', 'agent'],
+    category: 'workspace',
+    subcategory: 'search',
+    safety: 'read',
+    requiresApproval: false,
+    capability: { tier: '1', scopes: ['fs:read', 'workspace-only'] },
+    tags: ['workspace', 'search', 'atlas', 'index'],
+    schemas: {
+        input: WorkspaceSearchInputSchema,
+        output: WorkspaceSearchOutputSchema,
+        defaultAction: 'search',
+        // Per-action policy lives where every reader looks (schemas.actionSafety): manifests,
+        // sandbox policy and the capability catalog read only this field.
+        actionSafety: {
+            search: 'read',
+            graph: 'read',
+            symbol: 'read',
+            diagnostics: 'read',
+            'index-status': 'read',
+            'index-list': 'read',
+            'index-alias': 'read',
+            'index-alias-set': 'write',
+            'index-alias-remove': 'write',
+            'job-status': 'read',
+            'sync-status': 'read',
+            'index-create': 'write',
+            'index-incremental': 'write',
+            'index-delete': 'write',
+            'index-update': 'write',
+            rename: 'write'
+        }
+    },
+    examples: [
+        {
+            description: 'Semantic search',
+            input: { action: 'search', query: 'bindWorkspaceEnvironment', limit: 10 },
+            notes: 'Requires atlas index on consumer'
+        },
+        {
+            description: 'Sync status',
+            input: { action: 'sync-status' },
+            notes: 'Workspace file index + atlas state'
+        }
+    ]
+});
+//# sourceMappingURL=workspace-search.descriptor.js.map

package/dist/code-atlas/tools/workspace-search.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-search.descriptor.js","sourceRoot":"","sources":["../../../src/code-atlas/tools/workspace-search.descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,0BAA0B,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAExG,OAAO,EAAE,0BAA0B,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAGxG,eAAe,kBAAkB,CAAC;IACjC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,kBAAkB;IACtB,IAAI,EAAE,kBAAkB;IACxB,WAAW,EACV,kQAAkQ;IACnQ,cAAc,EACb,gNAAgN;IACjN,QAAQ,EAAE,CAAC,UAAU,CAAC;IACtB,OAAO,EAAE,CAAC,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC;IACnC,QAAQ,EAAE,WAAW;IACrB,WAAW,EAAE,QAAQ;IACrB,MAAM,EAAE,MAAM;IACd,gBAAgB,EAAE,KAAK;IACvB,UAAU,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,SAAS,EAAE,gBAAgB,CAAC,EAAE;IAChE,IAAI,EAAE,CAAC,WAAW,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC;IAC/C,OAAO,EAAE;QACR,KAAK,EAAE,0BAA0B;QACjC,MAAM,EAAE,2BAA2B;QACnC,aAAa,EAAE,QAAQ;QACvB,sFAAsF;QACtF,kEAAkE;QAClE,YAAY,EAAE;YACb,MAAM,EAAE,MAAM;YACd,KAAK,EAAE,MAAM;YACb,MAAM,EAAE,MAAM;YACd,WAAW,EAAE,MAAM;YACnB,cAAc,EAAE,MAAM;YACtB,YAAY,EAAE,MAAM;YACpB,aAAa,EAAE,MAAM;YACrB,iBAAiB,EAAE,OAAO;YAC1B,oBAAoB,EAAE,OAAO;YAC7B,YAAY,EAAE,MAAM;YACpB,aAAa,EAAE,MAAM;YACrB,cAAc,EAAE,OAAO;YACvB,mBAAmB,EAAE,OAAO;YAC5B,cAAc,EAAE,OAAO;YACvB,cAAc,EAAE,OAAO;YACvB,MAAM,EAAE,OAAO;SACf;KACD;IACD,QAAQ,EAAE;QACT;YACC,WAAW,EAAE,iBAAiB;YAC9B,KAAK,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,0BAA0B,EAAE,KAAK,EAAE,EAAE,EAAE;YACzE,KAAK,EAAE,kCAAkC;SACzC;QACD;YACC,WAAW,EAAE,aAAa;YAC1B,KAAK,EAAE,EAAE,MAAM,EAAE,aAAa,EAAE;YAChC,KAAK,EAAE,oCAAoC;SAC3C;KACD;CACD,CAAC,CAAC"}

package/dist/code-atlas/tools/workspace-search.impl.consumer.d.ts

@@ -0,0 +1,244 @@
+import type { VibesRuntime } from '@vibesdotdev/kernel';
+import type { ToolCallContext } from '@vibesdotdev/kernel/schemas/tool-call';
+import type { WorkspaceSearchInput } from './workspace-search.schemas.ts';
+declare const workspaceSearchImpl: {
+    execute(input: WorkspaceSearchInput, runtime: VibesRuntime, ctx: ToolCallContext): Promise<{
+        workspacePath: string;
+        projectId: string;
+        workspaceIndex: {
+            fileCount: number;
+            dirtyCount: number;
+            summary: string;
+            updatedAt?: string | undefined;
+        };
+        atlas?: {
+            exists: boolean;
+            summary?: string | undefined;
+        } | undefined;
+    } | {
+        projectId: string;
+        exists: boolean;
+        summary: string;
+        configId?: string | undefined;
+        latestRunId?: string | undefined;
+        filesProcessed?: number | undefined;
+        symbolsCaptured?: number | undefined;
+        lastRunCompletedAt?: string | undefined;
+        corpusFiles?: number | undefined;
+        corpusSymbols?: number | undefined;
+        latestRun?: {
+            id: string;
+            status: "cancelled" | "failed" | "pending" | "running" | "completed";
+            filesProcessed: number;
+            symbolsCaptured: number;
+            errors: string[];
+            completedAt?: string | undefined;
+        } | undefined;
+        emptyIndexInjury?: {
+            code: "atlas.empty-index";
+            filesProcessed: 0;
+            corpusFiles: 0;
+            message: string;
+        } | undefined;
+        freshness?: {
+            pendingChanges: number;
+            lastEnqueuedAt: string | null;
+            lastJobId: string | null;
+        } | undefined;
+    } | {
+        queryType: "path" | "cycles" | "fan-in" | "fan-out" | "impact-radius";
+        projectId: string;
+        summary: string;
+        nodes?: {
+            id: string;
+            label: string;
+        }[] | undefined;
+        edges?: {
+            sourceId: string;
+            targetId: string;
+            label?: string | undefined;
+        }[] | undefined;
+        cycles?: {
+            id: string;
+            label: string;
+        }[][] | undefined;
+        cycleEdges?: {
+            sourceId: string;
+            targetId: string;
+            label?: string | undefined;
+        }[][] | undefined;
+        total?: number | undefined;
+        path?: {
+            id: string;
+            label: string;
+        }[] | undefined;
+    } | {
+        results: {
+            type: "symbol" | "file" | "chunk";
+            content: string;
+            score: number;
+            location?: string | undefined;
+        }[];
+        mode: "symbol" | "file" | "text" | "semantic" | "hybrid";
+        warning?: string | undefined;
+        indexStatus?: {
+            runId: string;
+            status: "cancelled" | "failed" | "pending" | "running" | "completed";
+            filesProcessed: number;
+            symbolsCaptured: number;
+        } | undefined;
+    } | {
+        projectId: string;
+        summary: string;
+        symbol?: {
+            id: string;
+            name: string;
+            kind: string;
+            filePath: string;
+            startLine: number;
+            startColumn: number;
+            signature?: string | undefined;
+            exported?: boolean | undefined;
+            documentation?: string | undefined;
+        } | undefined;
+        matches?: {
+            id: string;
+            name: string;
+            kind: string;
+            filePath: string;
+            startLine: number;
+        }[] | undefined;
+        references?: {
+            filePath: string;
+        }[] | undefined;
+    } | {
+        indexes: {
+            projectId: string;
+            configId: string;
+            latestRunId?: string | undefined;
+            filesProcessed?: number | undefined;
+            symbolsCaptured?: number | undefined;
+            completedAt?: string | undefined;
+        }[];
+        summary: string;
+    } | {
+        changes?: {
+            path: string;
+            diff: string;
+        }[] | undefined;
+    } | {
+        configId: string;
+        count: number;
+        diagnostics: import("@vibesdotdev/workspace-schemas").StoredDiagnostic[];
+        summary: string;
+    } | {
+        projectId: string;
+        indexJobId: string;
+        options: {
+            paths: string[];
+            languages: string[];
+            enableEmbeddings: boolean;
+            enableLangServerEnrichment: boolean;
+            enableLangServerValidation: boolean;
+            force: boolean;
+            excludePaths?: string[] | undefined;
+        };
+        summary: string;
+        embeddingJobId?: string | undefined;
+    } | {
+        projectId: string;
+        jobId: string;
+        full: boolean;
+        summary: string;
+    } | {
+        projectId: string;
+        removedRuns: number;
+        summary: string;
+        filesIndexed?: number | undefined;
+        symbolsCaptured?: number | undefined;
+    } | {
+        projectId: string;
+        updated: boolean;
+        summary: string;
+        options?: {
+            paths?: string[] | undefined;
+            languages?: string[] | undefined;
+            enableEmbeddings?: boolean | undefined;
+            enableLangServerEnrichment?: boolean | undefined;
+            enableLangServerValidation?: boolean | undefined;
+        } | undefined;
+        triggeredJobs?: {
+            type: string;
+            jobId: string;
+        }[] | undefined;
+    } | {
+        aliases: {
+            alias: string;
+            target: string;
+        }[];
+        summary: string;
+        updatedAlias?: string | undefined;
+        removedAlias?: string | undefined;
+    } | {
+        summary: string;
+        job?: {
+            id: string;
+            status: string;
+            createdAt: string;
+            generation: number;
+            revision: number;
+            executionClaim: {
+                state: "none";
+            } | {
+                state: "unknown";
+            } | {
+                owner: string;
+                generation: number;
+                attempt: number;
+                state: "held";
+                heartbeatAt: string;
+            };
+            progress?: number | undefined;
+            startedAt?: string | undefined;
+            completedAt?: string | undefined;
+            attempts?: number | undefined;
+            projectId?: string | undefined;
+            data?: import("@vibesdotdev/kernel/schemas/json").JsonObject | undefined;
+            result?: unknown;
+            error?: string | undefined;
+            note?: string | undefined;
+        } | undefined;
+        jobs?: {
+            id: string;
+            status: string;
+            createdAt: string;
+            generation: number;
+            revision: number;
+            executionClaim: {
+                state: "none";
+            } | {
+                state: "unknown";
+            } | {
+                owner: string;
+                generation: number;
+                attempt: number;
+                state: "held";
+                heartbeatAt: string;
+            };
+            progress?: number | undefined;
+            startedAt?: string | undefined;
+            completedAt?: string | undefined;
+            attempts?: number | undefined;
+            projectId?: string | undefined;
+            data?: import("@vibesdotdev/kernel/schemas/json").JsonObject | undefined;
+            result?: unknown;
+            error?: string | undefined;
+            note?: string | undefined;
+        }[] | undefined;
+        scanned?: number | undefined;
+        complete?: boolean | undefined;
+        awaitingRetirementEvidence?: number | undefined;
+    }>;
+};
+export default workspaceSearchImpl;
+//# sourceMappingURL=workspace-search.impl.consumer.d.ts.map

package/dist/code-atlas/tools/workspace-search.impl.consumer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-search.impl.consumer.d.ts","sourceRoot":"","sources":["../../../src/code-atlas/tools/workspace-search.impl.consumer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AAE7E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAS1E,QAAA,MAAM,mBAAmB;mBACH,oBAAoB,WAAW,YAAY,OAAO,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBtF,CAAC;AAEF,eAAe,mBAAmB,CAAC"}

package/dist/code-atlas/tools/workspace-search.impl.consumer.js

@@ -0,0 +1,23 @@
+import { resolveWorkspaceEnvironment } from '@vibesdotdev/workspace/environment';
+async function assertSearchCapability(runtime) {
+    const environment = await resolveWorkspaceEnvironment(runtime);
+    if (!environment.capabilities.search) {
+        throw new Error('workspace-search is disabled for this workspace environment (capabilities.search=false)');
+    }
+}
+const workspaceSearchImpl = {
+    async execute(input, runtime, ctx) {
+        await assertSearchCapability(runtime);
+        if (input.action === 'sync-status') {
+            const syncStatusImpl = (await import("./workspace-sync-status/workspace-sync-status.impl.consumer.js")).default;
+            return syncStatusImpl.execute({
+                action: 'sync-status',
+                projectId: input.projectId
+            }, runtime, ctx);
+        }
+        const { atlas: atlasExecute } = await import("./code-atlas.impl.consumer.js");
+        return atlasExecute(runtime, input);
+    }
+};
+export default workspaceSearchImpl;
+//# sourceMappingURL=workspace-search.impl.consumer.js.map

package/dist/code-atlas/tools/workspace-search.impl.consumer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-search.impl.consumer.js","sourceRoot":"","sources":["../../../src/code-atlas/tools/workspace-search.impl.consumer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,2BAA2B,EAAE,MAAM,oCAAoC,CAAC;AAGjF,KAAK,UAAU,sBAAsB,CAAC,OAAqB;IAC1D,MAAM,WAAW,GAAG,MAAM,2BAA2B,CAAC,OAAO,CAAC,CAAC;IAC/D,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,yFAAyF,CAAC,CAAC;IAC5G,CAAC;AACF,CAAC;AAED,MAAM,mBAAmB,GAAG;IAC3B,KAAK,CAAC,OAAO,CAAC,KAA2B,EAAE,OAAqB,EAAE,GAAoB;QACrF,MAAM,sBAAsB,CAAC,OAAO,CAAC,CAAC;QAEtC,IAAI,KAAK,CAAC,MAAM,KAAK,aAAa,EAAE,CAAC;YACpC,MAAM,cAAc,GAAG,CACtB,MAAM,MAAM,CACX,gEAAgE,CAChE,CACD,CAAC,OAAO,CAAC;YACV,OAAO,cAAc,CAAC,OAAO,CAC5B;gBACC,MAAM,EAAE,aAAa;gBACrB,SAAS,EAAE,KAAK,CAAC,SAAS;aAC1B,EACD,OAAO,EACP,GAAG,CACH,CAAC;QACH,CAAC;QAED,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,MAAM,MAAM,CAC3C,+BAA+B,CAC/B,CAAC;QACF,OAAO,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IACrC,CAAC;CACD,CAAC;AAEF,eAAe,mBAAmB,CAAC"}

package/dist/code-atlas/tools/workspace-search.schemas.d.ts

@@ -0,0 +1,115 @@
+import z from 'zod/v4';
+export declare const WorkspaceSearchActions: readonly ["search", "graph", "symbol", "rename", "diagnostics", "index-status", "index-create", "index-incremental", "index-delete", "index-list", "index-update", "index-alias", "index-alias-set", "index-alias-remove", "job-status", "sync-status"];
+export declare const WorkspaceSearchInputSchema: z.ZodObject<{
+    action: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        symbol: "symbol";
+        search: "search";
+        diagnostics: "diagnostics";
+        rename: "rename";
+        graph: "graph";
+        "index-status": "index-status";
+        "index-create": "index-create";
+        "index-incremental": "index-incremental";
+        "index-delete": "index-delete";
+        "index-list": "index-list";
+        "index-update": "index-update";
+        "index-alias": "index-alias";
+        "index-alias-set": "index-alias-set";
+        "index-alias-remove": "index-alias-remove";
+        "job-status": "job-status";
+        "sync-status": "sync-status";
+    }>>>;
+    query: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        symbol: "symbol";
+        file: "file";
+        text: "text";
+        semantic: "semantic";
+        hybrid: "hybrid";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    includeContext: z.ZodOptional<z.ZodBoolean>;
+    raw: z.ZodOptional<z.ZodBoolean>;
+    queryType: z.ZodOptional<z.ZodEnum<{
+        path: "path";
+        cycles: "cycles";
+        "fan-in": "fan-in";
+        "fan-out": "fan-out";
+        "impact-radius": "impact-radius";
+    }>>;
+    nodeType: z.ZodOptional<z.ZodEnum<{
+        symbol: "symbol";
+        file: "file";
+        package: "package";
+    }>>;
+    packageName: z.ZodOptional<z.ZodString>;
+    targetPackage: z.ZodOptional<z.ZodString>;
+    includeDev: z.ZodOptional<z.ZodBoolean>;
+    nodeId: z.ZodOptional<z.ZodString>;
+    sourceNodeId: z.ZodOptional<z.ZodString>;
+    targetNodeId: z.ZodOptional<z.ZodString>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+    symbolId: z.ZodOptional<z.ZodString>;
+    symbolName: z.ZodOptional<z.ZodString>;
+    includeReferences: z.ZodOptional<z.ZodBoolean>;
+    path: z.ZodOptional<z.ZodString>;
+    line: z.ZodOptional<z.ZodNumber>;
+    column: z.ZodOptional<z.ZodNumber>;
+    newName: z.ZodOptional<z.ZodString>;
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    excludePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    languages: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        typescript: "typescript";
+        svelte: "svelte";
+        javascript: "javascript";
+    }>>>;
+    enableEmbeddings: z.ZodOptional<z.ZodBoolean>;
+    force: z.ZodOptional<z.ZodBoolean>;
+    list: z.ZodOptional<z.ZodLiteral<true>>;
+    alias: z.ZodOptional<z.ZodString>;
+    remove: z.ZodOptional<z.ZodLiteral<true>>;
+    targetProjectId: z.ZodOptional<z.ZodString>;
+    enableLangServerEnrichment: z.ZodOptional<z.ZodBoolean>;
+    enableLangServerValidation: z.ZodOptional<z.ZodBoolean>;
+    triggerReindex: z.ZodOptional<z.ZodBoolean>;
+    triggerIncremental: z.ZodOptional<z.ZodBoolean>;
+    triggerEmbeddings: z.ZodOptional<z.ZodBoolean>;
+    triggerEnrichment: z.ZodOptional<z.ZodBoolean>;
+    full: z.ZodOptional<z.ZodBoolean>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+    filePath: z.ZodOptional<z.ZodString>;
+    fileId: z.ZodOptional<z.ZodUUID>;
+    fileMtime: z.ZodOptional<z.ZodNumber>;
+    source: z.ZodOptional<z.ZodEnum<{
+        custom: "custom";
+        bun: "bun";
+        tsc: "tsc";
+        "svelte-check": "svelte-check";
+        vite: "vite";
+        eslint: "eslint";
+        prettier: "prettier";
+        vitest: "vitest";
+    }>>;
+    severity: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warning: "warning";
+        hint: "hint";
+    }>>;
+    includeStale: z.ZodOptional<z.ZodBoolean>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    jobId: z.ZodOptional<z.ZodString>;
+    queueName: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        failed: "failed";
+        pending: "pending";
+        completed: "completed";
+        processing: "processing";
+    }>>;
+    projectId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const WorkspaceSearchOutputSchema: z.ZodObject<{}, z.core.$loose>;
+export type WorkspaceSearchInput = z.infer<typeof WorkspaceSearchInputSchema>;
+export type WorkspaceSearchOutput = z.infer<typeof WorkspaceSearchOutputSchema>;
+//# sourceMappingURL=workspace-search.schemas.d.ts.map

package/dist/code-atlas/tools/workspace-search.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-search.schemas.d.ts","sourceRoot":"","sources":["../../../src/code-atlas/tools/workspace-search.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAEvB,eAAO,MAAM,sBAAsB,yPAiBzB,CAAC;AAEX,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgErC,CAAC;AAEH,eAAO,MAAM,2BAA2B,gCAAoB,CAAC;AAE7D,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}