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

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

@@ -0,0 +1,466 @@
+/**
+ * Code Atlas Tool Implementation
+ *
+ * Routes to specific handlers based on action field using dynamic imports.
+ * Each action handler is loaded on-demand for optimal code splitting.
+ */
+import type { VibesRuntime } from '@vibesdotdev/kernel';
+import type { ToolCallContext } from '@vibesdotdev/kernel/schemas/tool-call';
+import type { WorkspaceAtlasInput } from './workspace-atlas.schemas.ts';
+import type { WorkspaceSearchInput } from './workspace-search.schemas.ts';
+/** What the workspace-search and workspace-atlas tools hand the router: their own wire input. */
+type AtlasToolInput = WorkspaceSearchInput | WorkspaceAtlasInput;
+/** Parse the tool input into one action's shape, then route it to that action's handler. */
+declare function executeAction(runtime: VibesRuntime, toolInput: AtlasToolInput): 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;
+}>;
+declare const _default: {
+    execute(input: AtlasToolInput, 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 _default;
+export { executeAction as atlas };
+//# sourceMappingURL=code-atlas.impl.consumer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"code-atlas.impl.consumer.d.ts","sourceRoot":"","sources":["../../../src/code-atlas/tools/code-atlas.impl.consumer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AAI7E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAE1E,iGAAiG;AACjG,KAAK,cAAc,GAAG,oBAAoB,GAAG,mBAAmB,CAAC;AAEjE,4FAA4F;AAC5F,iBAAe,aAAa,CAAC,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmE5E;;mBAGe,cAAc,WAAW,YAAY,QAAQ,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAD5E,wBAIE;AAEF,OAAO,EAAE,aAAa,IAAI,KAAK,EAAE,CAAC"}

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

@@ -0,0 +1,83 @@
+/**
+ * Code Atlas Tool Implementation
+ *
+ * Routes to specific handlers based on action field using dynamic imports.
+ * Each action handler is loaded on-demand for optimal code splitting.
+ */
+import { AtlasInputSchema } from "./schemas.js";
+import { AtlasSymbolInputSchema } from "./symbol/schemas.js";
+import { AtlasIndexListInputSchema } from "./index-management/list/schemas.js";
+/** Parse the tool input into one action's shape, then route it to that action's handler. */
+async function executeAction(runtime, toolInput) {
+    const input = AtlasInputSchema.parse(toolInput);
+    switch (input.action) {
+        case 'search': {
+            const { atlasSearch } = await import("./search/implementation.js");
+            return atlasSearch(runtime, input);
+        }
+        case 'graph': {
+            const { atlasGraph } = await import("./graph/implementation.js");
+            return atlasGraph(runtime, input);
+        }
+        case 'symbol': {
+            const { atlasSymbol } = await import("./symbol/implementation.js");
+            // A symbol is looked up by id or by name: its own schema requires one of them.
+            return atlasSymbol(runtime, AtlasSymbolInputSchema.parse(input));
+        }
+        case 'rename': {
+            const { atlasRename } = await import("./rename/implementation.js");
+            return atlasRename(runtime, input);
+        }
+        case 'diagnostics': {
+            const { atlasDiagnostics } = await import("./diagnostics/implementation.js");
+            return atlasDiagnostics(runtime, input);
+        }
+        case 'index-status': {
+            const { atlasIndexStatus } = await import("./index-management/status/implementation.js");
+            return atlasIndexStatus(runtime, input);
+        }
+        case 'index-create': {
+            const { atlasIndexCreate } = await import("./index-management/create/implementation.js");
+            return atlasIndexCreate(runtime, input);
+        }
+        case 'index-incremental': {
+            const { atlasIndexIncremental } = await import("./index-management/incremental/implementation.js");
+            return atlasIndexIncremental(runtime, input);
+        }
+        case 'index-delete': {
+            const { atlasIndexDelete } = await import("./index-management/delete/implementation.js");
+            return atlasIndexDelete(runtime, input);
+        }
+        case 'index-list': {
+            const { atlasIndexList } = await import("./index-management/list/implementation.js");
+            return atlasIndexList(runtime, AtlasIndexListInputSchema.parse(input));
+        }
+        case 'index-update': {
+            const { atlasIndexUpdate } = await import("./index-management/update/implementation.js");
+            return atlasIndexUpdate(runtime, input);
+        }
+        case 'index-alias': {
+            const { atlasIndexAlias } = await import("./index-management/alias/implementation.js");
+            return atlasIndexAlias(runtime, input);
+        }
+        case 'index-alias-set': {
+            const { atlasIndexAliasSet } = await import("./index-management/alias/implementation.js");
+            return atlasIndexAliasSet(runtime, input);
+        }
+        case 'index-alias-remove': {
+            const { atlasIndexAliasRemove } = await import("./index-management/alias/implementation.js");
+            return atlasIndexAliasRemove(runtime, input);
+        }
+        case 'job-status': {
+            const { atlasJobStatus } = await import("./index-management/job-status/implementation.js");
+            return atlasJobStatus(runtime, input);
+        }
+    }
+}
+export default {
+    execute(input, runtime, _ctx) {
+        return executeAction(runtime, input);
+    }
+};
+export { executeAction as atlas };
+//# sourceMappingURL=code-atlas.impl.consumer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"code-atlas.impl.consumer.js","sourceRoot":"","sources":["../../../src/code-atlas/tools/code-atlas.impl.consumer.ts"],"names":[],"mappings":"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"}

package/dist/code-atlas/tools/diagnostics/implementation.d.ts

@@ -0,0 +1,20 @@
+import type { VibesRuntime } from '@vibesdotdev/kernel';
+import type { DiagnosticQuery, StoredDiagnostic } from '@vibesdotdev/workspace-schemas/diagnostics';
+export declare function atlasDiagnostics(runtime: VibesRuntime, input: {
+    projectId?: string;
+    filePath?: string;
+    fileId?: string;
+    fileMtime?: number;
+    query?: string;
+    source?: DiagnosticQuery['source'];
+    severity?: DiagnosticQuery['severity'];
+    includeStale?: boolean;
+    limit?: number;
+    offset?: number;
+}): Promise<{
+    configId: string;
+    count: number;
+    diagnostics: StoredDiagnostic[];
+    summary: string;
+}>;
+//# sourceMappingURL=implementation.d.ts.map

package/dist/code-atlas/tools/diagnostics/implementation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"implementation.d.ts","sourceRoot":"","sources":["../../../../src/code-atlas/tools/diagnostics/implementation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAEpG,wBAAsB,gBAAgB,CACrC,OAAO,EAAE,YAAY,EACrB,KAAK,EAAE;IACN,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAC;IACnC,QAAQ,CAAC,EAAE,eAAe,CAAC,UAAU,CAAC,CAAC;IACvC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB,GACC,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,gBAAgB,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAiChG"}

package/dist/code-atlas/tools/diagnostics/implementation.js

@@ -0,0 +1,32 @@
+import { resolveAtlasProjectId } from "../helpers.js";
+export async function atlasDiagnostics(runtime, input) {
+    const { createAtlasStorage, getDefaultStorageOptions } = await import('@vibesdotdev/workspace/codegraph/storage');
+    const workspacePath = await runtime.context('runtime/workspace-path');
+    const { projectId: projId } = await resolveAtlasProjectId(runtime, input.projectId, workspacePath);
+    const storage = await createAtlasStorage({ ...getDefaultStorageOptions(projId, workspacePath), runtime });
+    try {
+        const config = await storage.getConfigByProject(projId);
+        if (!config) {
+            throw new Error('No index found. Run indexing first.');
+        }
+        const query = {
+            configId: config.id,
+            filePath: input.filePath,
+            fileId: input.fileId,
+            fileMtime: input.fileMtime,
+            query: input.query,
+            source: input.source,
+            severity: input.severity,
+            includeStale: input.includeStale ?? false,
+            limit: input.limit ?? 100,
+            offset: input.offset ?? 0
+        };
+        const diagnostics = await storage.queryDiagnostics(query);
+        const summary = `Found ${diagnostics.length} diagnostic${diagnostics.length === 1 ? '' : 's'}`;
+        return { configId: config.id, count: diagnostics.length, diagnostics, summary };
+    }
+    finally {
+        await storage.close();
+    }
+}
+//# sourceMappingURL=implementation.js.map

package/dist/code-atlas/tools/diagnostics/implementation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"implementation.js","sourceRoot":"","sources":["../../../../src/code-atlas/tools/diagnostics/implementation.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAGtD,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACrC,OAAqB,EACrB,KAWC;IAED,MAAM,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,GAAG,MAAM,MAAM,CAAC,0CAA0C,CAAC,CAAC;IAElH,MAAM,aAAa,GAAG,MAAM,OAAO,CAAC,OAAO,CAAS,wBAAwB,CAAC,CAAC;IAC9E,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM,qBAAqB,CAAC,OAAO,EAAE,KAAK,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;IACnG,MAAM,OAAO,GAAG,MAAM,kBAAkB,CAAC,EAAE,GAAG,wBAAwB,CAAC,MAAM,EAAE,aAAa,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;IAE1G,IAAI,CAAC;QACJ,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;QACxD,IAAI,CAAC,MAAM,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;QACxD,CAAC;QAED,MAAM,KAAK,GAAoB;YAC9B,QAAQ,EAAE,MAAM,CAAC,EAAE;YACnB,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,MAAM,EAAE,KAAK,CAAC,MAAM;YACpB,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,MAAM,EAAE,KAAK,CAAC,MAAM;YACpB,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,YAAY,EAAE,KAAK,CAAC,YAAY,IAAI,KAAK;YACzC,KAAK,EAAE,KAAK,CAAC,KAAK,IAAI,GAAG;YACzB,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC;SACzB,CAAC;QAEF,MAAM,WAAW,GAAG,MAAM,OAAO,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAC1D,MAAM,OAAO,GAAG,SAAS,WAAW,CAAC,MAAM,cAAc,WAAW,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;QAE/F,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC;IACjF,CAAC;YAAS,CAAC;QACV,MAAM,OAAO,CAAC,KAAK,EAAE,CAAC;IACvB,CAAC;AACF,CAAC"}

package/dist/code-atlas/tools/graph/cycles.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Cycle selection for the Atlas graph tool: scope to a path, order smallest first,
+ * bound by a limit, and keep each cycle's edges so it can be attributed.
+ */
+/** Cycles returned when the caller names no limit: enough to act on, small enough to read. */
+export declare const CYCLE_LIMIT_DEFAULT = 20;
+interface CycleNode {
+    readonly id: string;
+    readonly label: string;
+}
+interface CycleEdge {
+    readonly sourceId: string;
+    readonly targetId: string;
+}
+interface Cycle {
+    readonly nodes: readonly CycleNode[];
+    readonly edges: readonly CycleEdge[];
+}
+/** Atlas node labels are workspace-relative paths; accept an absolute or relative prefix. */
+export declare function toWorkspaceRelative(path: string, workspacePath: string): string;
+export interface SelectedCycles {
+    readonly total: number;
+    readonly prefix: string | undefined;
+    readonly cycles: Array<Array<{
+        id: string;
+        label: string;
+    }>>;
+    readonly cycleEdges: Array<Array<{
+        sourceId: string;
+        targetId: string;
+    }>>;
+}
+export declare function selectCycles(all: readonly Cycle[], options: {
+    path?: string;
+    limit?: number;
+    workspacePath: string;
+}): SelectedCycles;
+export {};
+//# sourceMappingURL=cycles.d.ts.map

package/dist/code-atlas/tools/graph/cycles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cycles.d.ts","sourceRoot":"","sources":["../../../../src/code-atlas/tools/graph/cycles.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,8FAA8F;AAC9F,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC,UAAU,SAAS;IAClB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACvB;AACD,UAAU,SAAS;IAClB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC1B;AACD,UAAU,KAAK;IACd,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC;CACrC;AAED,6FAA6F;AAC7F,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAI/E;AAED,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAC;IAC7D,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAC;CAC1E;AAED,wBAAgB,YAAY,CAC3B,GAAG,EAAE,SAAS,KAAK,EAAE,EACrB,OAAO,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GAC/D,cAAc,CAYhB"}