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

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

@@ -0,0 +1,149 @@
+declare const _default: {
+    readonly kind: "tools/tool";
+    readonly id: "workspace-atlas";
+    readonly name: "Workspace Atlas";
+    readonly description: "High-level topographical map of a repository (file tree summaries, exported symbols, dependency graphs).";
+    readonly mcpDescription: "Explore code structure. Ex: {action:\"graph\",path:\"src/\"} or {action:\"symbol\"}.";
+    readonly hardware: ["consumer", "cloud"];
+    readonly purpose: ["direct", "mcp", "agent"];
+    readonly category: "workspace";
+    readonly subcategory: "atlas";
+    readonly safety: "read";
+    readonly requiresApproval: false;
+    readonly capability: {
+        readonly tier: "1";
+        readonly scopes: ["fs:read", "workspace-only"];
+    };
+    readonly tags: ["workspace", "atlas", "graph", "symbols"];
+    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: "graph";
+    };
+    readonly examples: [{
+        readonly description: "View dependency graph for a path";
+        readonly input: {
+            readonly action: "graph";
+            readonly path: "src/index.ts";
+            readonly maxDepth: 2;
+        };
+        readonly notes: "Requires atlas index on consumer";
+    }, {
+        readonly description: "Look up a symbol";
+        readonly input: {
+            readonly action: "symbol";
+            readonly query: "WorkspaceAtlas";
+        };
+        readonly notes: "Finds exported symbols matching the query";
+    }];
+};
+export default _default;
+//# sourceMappingURL=workspace-atlas.descriptor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-atlas.descriptor.d.ts","sourceRoot":"","sources":["../../../src/code-atlas/tools/workspace-atlas.descriptor.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,wBA+BG"}

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

@@ -0,0 +1,35 @@
+import { createRuntimeAsset } from '@vibesdotdev/kernel/factory';
+import { WorkspaceAtlasInputSchema, WorkspaceAtlasOutputSchema } from "./workspace-atlas.schemas.js";
+export default createRuntimeAsset({
+    kind: 'tools/tool',
+    id: 'workspace-atlas',
+    name: 'Workspace Atlas',
+    description: 'High-level topographical map of a repository (file tree summaries, exported symbols, dependency graphs).',
+    mcpDescription: 'Explore code structure. Ex: {action:"graph",path:"src/"} or {action:"symbol"}.',
+    hardware: ['consumer', 'cloud'],
+    purpose: ['direct', 'mcp', 'agent'],
+    category: 'workspace',
+    subcategory: 'atlas',
+    safety: 'read',
+    requiresApproval: false,
+    capability: { tier: '1', scopes: ['fs:read', 'workspace-only'] },
+    tags: ['workspace', 'atlas', 'graph', 'symbols'],
+    schemas: {
+        input: WorkspaceAtlasInputSchema,
+        output: WorkspaceAtlasOutputSchema,
+        defaultAction: 'graph'
+    },
+    examples: [
+        {
+            description: 'View dependency graph for a path',
+            input: { action: 'graph', path: 'src/index.ts', maxDepth: 2 },
+            notes: 'Requires atlas index on consumer'
+        },
+        {
+            description: 'Look up a symbol',
+            input: { action: 'symbol', query: 'WorkspaceAtlas' },
+            notes: 'Finds exported symbols matching the query'
+        }
+    ]
+});
+//# sourceMappingURL=workspace-atlas.descriptor.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-atlas.descriptor.js","sourceRoot":"","sources":["../../../src/code-atlas/tools/workspace-atlas.descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,yBAAyB,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAErG,eAAe,kBAAkB,CAAC;IACjC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,iBAAiB;IACrB,IAAI,EAAE,iBAAiB;IACvB,WAAW,EAAE,0GAA0G;IACvH,cAAc,EAAE,gFAAgF;IAChG,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC;IAC/B,OAAO,EAAE,CAAC,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC;IACnC,QAAQ,EAAE,WAAW;IACrB,WAAW,EAAE,OAAO;IACpB,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,OAAO,EAAE,OAAO,EAAE,SAAS,CAAC;IAChD,OAAO,EAAE;QACR,KAAK,EAAE,yBAAyB;QAChC,MAAM,EAAE,0BAA0B;QAClC,aAAa,EAAE,OAAO;KACtB;IACD,QAAQ,EAAE;QACT;YACC,WAAW,EAAE,kCAAkC;YAC/C,KAAK,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,CAAC,EAAE;YAC7D,KAAK,EAAE,kCAAkC;SACzC;QACD;YACC,WAAW,EAAE,kBAAkB;YAC/B,KAAK,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,gBAAgB,EAAE;YACpD,KAAK,EAAE,2CAA2C;SAClD;KACD;CACD,CAAC,CAAC"}

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

@@ -0,0 +1,231 @@
+import type { VibesRuntime } from '@vibesdotdev/kernel';
+import type { ToolCallContext } from '@vibesdotdev/kernel/schemas/tool-call';
+import type { WorkspaceAtlasInput } from './workspace-atlas.schemas.ts';
+declare const workspaceAtlasImpl: {
+    execute(input: WorkspaceAtlasInput, runtime: VibesRuntime, _ctx: ToolCallContext): Promise<{
+        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 workspaceAtlasImpl;
+//# sourceMappingURL=workspace-atlas.impl.consumer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-atlas.impl.consumer.d.ts","sourceRoot":"","sources":["../../../src/code-atlas/tools/workspace-atlas.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,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AASxE,QAAA,MAAM,kBAAkB;mBACF,mBAAmB,WAAW,YAAY,QAAQ,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOtF,CAAC;AAEF,eAAe,kBAAkB,CAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-atlas.impl.consumer.js","sourceRoot":"","sources":["../../../src/code-atlas/tools/workspace-atlas.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,wFAAwF,CAAC,CAAC;IAC3G,CAAC;AACF,CAAC;AAED,MAAM,kBAAkB,GAAG;IAC1B,KAAK,CAAC,OAAO,CAAC,KAA0B,EAAE,OAAqB,EAAE,IAAqB;QACrF,MAAM,sBAAsB,CAAC,OAAO,CAAC,CAAC;QACtC,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,kBAAkB,CAAC"}

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

@@ -0,0 +1,118 @@
+import z from 'zod/v4';
+/**
+ * workspace-atlas routes to the same Atlas actions as workspace-search, so it takes the same typed
+ * input: an untyped passthrough let clients send `limit: "5"`, which the router then refused.
+ */
+export declare const WorkspaceAtlasInputSchema: 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 WorkspaceAtlasOutputSchema: z.ZodObject<{}, z.core.$loose>;
+export type WorkspaceAtlasInput = z.infer<typeof WorkspaceAtlasInputSchema>;
+export type WorkspaceAtlasOutput = z.infer<typeof WorkspaceAtlasOutputSchema>;
+//# sourceMappingURL=workspace-atlas.schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-atlas.schemas.d.ts","sourceRoot":"","sources":["../../../src/code-atlas/tools/workspace-atlas.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAIvB;;;GAGG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA6B,CAAC;AACpE,eAAO,MAAM,0BAA0B,gCAAoB,CAAC;AAE5D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}

package/dist/code-atlas/tools/workspace-atlas.schemas.js

@@ -0,0 +1,9 @@
+import z from 'zod/v4';
+import { WorkspaceSearchInputSchema } from "./workspace-search.schemas.js";
+/**
+ * workspace-atlas routes to the same Atlas actions as workspace-search, so it takes the same typed
+ * input: an untyped passthrough let clients send `limit: "5"`, which the router then refused.
+ */
+export const WorkspaceAtlasInputSchema = WorkspaceSearchInputSchema;
+export const WorkspaceAtlasOutputSchema = z.looseObject({});
+//# sourceMappingURL=workspace-atlas.schemas.js.map

package/dist/code-atlas/tools/workspace-atlas.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-atlas.schemas.js","sourceRoot":"","sources":["../../../src/code-atlas/tools/workspace-atlas.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAEvB,OAAO,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC;AAE3E;;;GAGG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,0BAA0B,CAAC;AACpE,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC"}