byterover-cli 3.2.0 → 3.4.0

package/dist/oclif/commands/search.js

@@ -0,0 +1,186 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { randomUUID } from 'node:crypto';
+import { TaskEvents } from '../../shared/transport/events/index.js';
+import { encodeSearchContent } from '../../shared/transport/search-content.js';
+import { formatConnectionError, hasLeakedHandles, withDaemonRetry, } from '../lib/daemon-client.js';
+import { writeJsonResponse } from '../lib/json-response.js';
+import { formatSearchTextOutput } from '../lib/search-format.js';
+import { waitForTaskCompletion } from '../lib/task-client.js';
+export default class Search extends Command {
+    static args = {
+        query: Args.string({
+            description: 'Search query to find relevant knowledge in the context tree',
+            required: true,
+        }),
+    };
+    static description = `Search the context tree for relevant knowledge
+
+Returns ranked results with paths, scores, and excerpts.
+Pure BM25 retrieval — no LLM, no token cost.
+
+Use this for structured results with file paths.
+Use "brv query" when you need a synthesized answer.`;
+    static examples = [
+        '# Search for knowledge about authentication',
+        '<%= config.bin %> <%= command.id %> "authentication"',
+        '',
+        '# Limit results and scope to a domain',
+        '<%= config.bin %> <%= command.id %> "JWT tokens" --limit 5 --scope auth/',
+        '',
+        '# JSON output (for automation)',
+        '<%= config.bin %> <%= command.id %> "auth" --format json',
+    ];
+    static flags = {
+        format: Flags.string({
+            default: 'text',
+            description: 'Output format (text or json)',
+            options: ['text', 'json'],
+        }),
+        limit: Flags.integer({
+            default: 10,
+            description: 'Maximum number of results (1-50)',
+            max: 50,
+            min: 1,
+        }),
+        scope: Flags.string({
+            description: 'Path prefix to scope results (e.g. "auth/" for auth domain only)',
+        }),
+    };
+    static strict = false;
+    getDaemonClientOptions() {
+        return {};
+    }
+    async run() {
+        const { args, flags } = await this.parse(Search);
+        const format = flags.format === 'json' ? 'json' : 'text';
+        if (!this.validateInput(args.query, format))
+            return;
+        try {
+            await withDaemonRetry(async (client, projectRoot, worktreeRoot) => {
+                // No provider validation — search is pure BM25, no LLM needed.
+                await this.submitTask({
+                    client,
+                    format,
+                    limit: flags.limit,
+                    projectRoot,
+                    query: args.query,
+                    scope: flags.scope,
+                    worktreeRoot,
+                });
+            }, {
+                ...this.getDaemonClientOptions(),
+                onRetry: format === 'text'
+                    ? (attempt, maxRetries) => this.log(`\nConnection lost. Restarting daemon... (attempt ${attempt}/${maxRetries})`)
+                    : undefined,
+            });
+        }
+        catch (error) {
+            this.reportError(error, format);
+        }
+    }
+    reportError(error, format) {
+        const errorMessage = error instanceof Error ? error.message : 'Search failed';
+        if (format === 'json') {
+            writeJsonResponse({ command: 'search', data: { error: errorMessage, status: 'error' }, success: false });
+        }
+        else {
+            this.log(formatConnectionError(error));
+        }
+        if (hasLeakedHandles(error)) {
+            // eslint-disable-next-line n/no-process-exit, unicorn/no-process-exit
+            process.exit(1);
+        }
+    }
+    async submitTask(props) {
+        const { client, format, projectRoot, query, worktreeRoot } = props;
+        const taskId = randomUUID();
+        const contentPayload = encodeSearchContent({ limit: props.limit, query, scope: props.scope });
+        const taskPayload = {
+            clientCwd: process.cwd(),
+            content: contentPayload,
+            ...(projectRoot ? { projectPath: projectRoot } : {}),
+            taskId,
+            type: 'search',
+            ...(worktreeRoot ? { worktreeRoot } : {}),
+        };
+        const completionPromise = waitForTaskCompletion({
+            client,
+            command: 'search',
+            format,
+            onCompleted: ({ result }) => {
+                if (!result) {
+                    if (format === 'json') {
+                        writeJsonResponse({
+                            command: 'search',
+                            data: { results: [], status: 'completed', totalFound: 0 },
+                            success: true,
+                        });
+                    }
+                    else {
+                        this.log('\nNo results.\n');
+                    }
+                    return;
+                }
+                try {
+                    const searchResult = JSON.parse(result);
+                    if (format === 'json') {
+                        writeJsonResponse({
+                            command: 'search',
+                            data: {
+                                ...searchResult,
+                                status: 'completed',
+                            },
+                            success: true,
+                        });
+                    }
+                    else {
+                        for (const line of formatSearchTextOutput(searchResult)) {
+                            this.log(line);
+                        }
+                    }
+                }
+                catch {
+                    // Fallback: result isn't valid JSON — display as-is
+                    if (format === 'json') {
+                        writeJsonResponse({
+                            command: 'search',
+                            data: { error: 'Invalid search result format', raw: result, status: 'error' },
+                            success: false,
+                        });
+                    }
+                    else {
+                        this.log(`\n${result}\n`);
+                    }
+                }
+            },
+            onError({ error }) {
+                if (format === 'json') {
+                    writeJsonResponse({
+                        command: 'search',
+                        data: { event: 'error', message: error.message, status: 'error' },
+                        success: false,
+                    });
+                }
+            },
+            taskId,
+        }, (msg) => this.log(msg));
+        await client.requestWithAck(TaskEvents.CREATE, taskPayload);
+        await completionPromise;
+    }
+    validateInput(query, format) {
+        if (query.trim())
+            return true;
+        if (format === 'json') {
+            writeJsonResponse({
+                command: 'search',
+                data: { message: 'Search query is required.', status: 'error' },
+                success: false,
+            });
+        }
+        else {
+            this.log('Search query is required.');
+            this.log('Usage: brv search "your query here"');
+        }
+        return false;
+    }
+}

package/dist/oclif/commands/status.js

@@ -139,6 +139,10 @@ export default class Status extends Command {
                 this.log('Context Tree: No changes');
                 break;
             }
+            case 'no_vc': {
+                this.log('Context Tree: Managed by Byterover version control (use brv vc commands)');
+                break;
+            }
             case 'not_initialized': {
                 this.log('Context Tree: Not initialized');
                 break;

package/dist/oclif/commands/swarm/curate.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class SwarmCurate extends Command {
+    static args: {
+        content: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        provider: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/oclif/commands/swarm/curate.js

@@ -0,0 +1,81 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { FileSystemService } from '../../../agent/infra/file-system/file-system-service.js';
+import { loadSwarmConfig } from '../../../agent/infra/swarm/config/swarm-config-loader.js';
+import { buildProvidersFromConfig } from '../../../agent/infra/swarm/provider-factory.js';
+import { SwarmCoordinator } from '../../../agent/infra/swarm/swarm-coordinator.js';
+import { validateSwarmProviders } from '../../../agent/infra/swarm/validation/config-validator.js';
+import { createSearchKnowledgeService } from '../../../agent/infra/tools/implementations/search-knowledge-service.js';
+export default class SwarmCurate extends Command {
+    static args = {
+        content: Args.string({ description: 'Knowledge content to store in a swarm provider', required: true }),
+    };
+    static description = 'Store knowledge in a swarm provider (GBrain, local markdown)';
+    static examples = [
+        '<%= config.bin %> swarm curate "Dario Amodei is CEO of Anthropic"',
+        '<%= config.bin %> swarm curate "meeting notes: decided on JWT" --provider local-markdown:notes',
+        '<%= config.bin %> swarm curate "Architecture uses event sourcing" --provider gbrain',
+    ];
+    static flags = {
+        format: Flags.string({
+            char: 'f',
+            default: 'text',
+            description: 'Output format',
+            options: ['text', 'json'],
+        }),
+        provider: Flags.string({
+            char: 'p',
+            description: 'Target provider ID (e.g., gbrain, local-markdown:notes)',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(SwarmCurate);
+        const isJson = flags.format === 'json';
+        try {
+            const config = await loadSwarmConfig(process.cwd());
+            // Validate enrichment topology only (provider errors handled by health checks)
+            const validation = await validateSwarmProviders(config);
+            const topologyErrors = validation.errors.filter((e) => e.provider === 'enrichment');
+            if (topologyErrors.length > 0) {
+                const messages = topologyErrors.map((e) => e.message);
+                throw new Error(`Invalid enrichment topology:\n  ${messages.join('\n  ')}`);
+            }
+            const workingDirectory = process.cwd();
+            const fileSystemService = new FileSystemService({ workingDirectory });
+            await fileSystemService.initialize();
+            const searchService = createSearchKnowledgeService(fileSystemService, {
+                baseDirectory: workingDirectory,
+            });
+            const providers = buildProvidersFromConfig(config, { searchService });
+            const coordinator = new SwarmCoordinator(providers, config);
+            await coordinator.refreshHealth();
+            const result = await coordinator.store({
+                content: args.content,
+                provider: flags.provider,
+            });
+            if (isJson) {
+                this.log(JSON.stringify(result, undefined, 2));
+            }
+            else if (result.success && result.fallback) {
+                const idPart = result.id ? ` as ${result.id}` : '';
+                this.log(`Stored to ${result.provider} (fallback — no external providers available)${idPart}`);
+            }
+            else if (result.success) {
+                this.log(`Stored to ${result.provider} as ${result.id}`);
+            }
+            else {
+                this.logToStderr(`Error: ${result.error ?? 'Store failed'}`);
+                this.exit(2);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (isJson) {
+                this.log(JSON.stringify({ error: message, success: false }));
+            }
+            else {
+                this.logToStderr(`Error: ${message}`);
+                this.exit(2);
+            }
+        }
+    }
+}

package/dist/oclif/commands/swarm/onboard.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class SwarmOnboard extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/oclif/commands/swarm/onboard.js

@@ -0,0 +1,233 @@
+/* eslint-disable camelcase -- wizard builds YAML-shaped config objects (snake_case keys) */
+import { checkbox, confirm, input, select } from '@inquirer/prompts';
+import { Command } from '@oclif/core';
+import chalk from 'chalk';
+import { load } from 'js-yaml';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { safeValidateSwarmConfig } from '../../../agent/infra/swarm/config/swarm-config-schema.js';
+import { scaffoldConfig } from '../../../agent/infra/swarm/wizard/config-scaffolder.js';
+import { detectProviders } from '../../../agent/infra/swarm/wizard/provider-detector.js';
+import { EscBackError, runMemoryWizard, WizardCancelledError } from '../../../agent/infra/swarm/wizard/swarm-wizard.js';
+import { createEscapeSignal, isEscBack, isForceExit, isPromptCancelled, wizardInputTheme, wizardSelectTheme } from '../../lib/prompt-utils.js';
+/**
+ * Wrap a prompt call with ESC back-navigation support.
+ * If the user presses ESC, throws EscBackError so the wizard goes back one step.
+ * If the user presses Ctrl+C, re-throws so the command exits.
+ */
+async function withEscBack(esc, fn) {
+    try {
+        return await fn(esc.signal);
+    }
+    catch (error) {
+        if (isEscBack(error)) {
+            esc.reset();
+            throw new EscBackError();
+        }
+        if (isForceExit(error)) {
+            throw error;
+        }
+        throw error;
+    }
+}
+/**
+ * Create the real wizard prompts backed by @inquirer/prompts.
+ * Wires createEscapeSignal() for ESC back-navigation on every prompt.
+ */
+function createWizardPrompts(esc) {
+    return {
+        async configureBudget() {
+            const amount = await withEscBack(esc, (signal) => input({
+                default: '50',
+                message: 'Monthly budget cap in dollars:',
+                theme: wizardInputTheme,
+            }, { signal }));
+            const cents = Math.round(Number.parseFloat(amount) * 100);
+            return { globalMonthlyCents: cents };
+        },
+        async configureEnrichment(providerIds) {
+            const providerList = providerIds.filter((id) => id !== 'byterover').join(', ');
+            console.log('');
+            console.log(chalk.bold('Enrichment Topology'));
+            console.log(chalk.dim('─'.repeat(50)));
+            console.log('');
+            console.log('The swarm can run providers in two modes:');
+            console.log('');
+            console.log(`  ${chalk.cyan('Parallel')} (enrichment off)`);
+            console.log('    All providers search independently at the same time.');
+            console.log('    Fastest, but each provider only sees your original query.');
+            console.log('');
+            console.log(`  ${chalk.cyan('Chained')} (enrichment on) ${chalk.green('← recommended')}`);
+            console.log(`    ByteRover searches first, then feeds its results to ${providerList}.`);
+            console.log('    Slightly slower, but downstream providers get richer context');
+            console.log('    from ByteRover\'s structured knowledge.');
+            console.log('');
+            console.log(chalk.dim('How routing interacts with enrichment:'));
+            console.log(chalk.dim('  The router decides WHICH providers handle each query type.'));
+            console.log(chalk.dim('  Enrichment decides the ORDER they run in.'));
+            console.log(chalk.dim('  If a provider is excluded by routing, its enrichment edge is skipped.'));
+            console.log('');
+            return withEscBack(esc, (signal) => confirm({
+                default: true,
+                message: 'Enable enrichment (recommended)?',
+            }, { signal }));
+        },
+        async configureProvider(provider) {
+            const config = {};
+            switch (provider.id) {
+                case 'gbrain': {
+                    config.repo_path = await withEscBack(esc, (signal) => input({
+                        message: 'GBrain brain repository path (your notes/data repo, not the CLI checkout):',
+                        theme: wizardInputTheme,
+                    }, { signal }));
+                    config.search_mode = await withEscBack(esc, (signal) => select({
+                        choices: [
+                            { description: 'Vector + keyword + RRF fusion (best recall, needs OPENAI_API_KEY)', name: 'hybrid (recommended)', value: 'hybrid' },
+                            { description: 'Full-text search only (fast, no API key needed)', name: 'keyword', value: 'keyword' },
+                            { description: 'Vector similarity only (needs OPENAI_API_KEY)', name: 'vector', value: 'vector' },
+                        ],
+                        default: 'hybrid',
+                        message: 'Search mode:',
+                        theme: wizardSelectTheme,
+                    }, { signal }));
+                    break;
+                }
+                case 'hindsight': {
+                    config.connection_string = await withEscBack(esc, (signal) => input({
+                        // eslint-disable-next-line no-template-curly-in-string -- literal ${VAR} placeholder for resolveEnvVars
+                        default: '${HINDSIGHT_DB_URL}',
+                        message: 'Hindsight connection string:',
+                        theme: wizardInputTheme,
+                    }, { signal }));
+                    break;
+                }
+                case 'honcho': {
+                    config.api_key = await withEscBack(esc, (signal) => input({
+                        // eslint-disable-next-line no-template-curly-in-string -- literal ${VAR} placeholder for resolveEnvVars
+                        default: '${HONCHO_API_KEY}',
+                        message: 'Honcho API key (or env var reference):',
+                        theme: wizardInputTheme,
+                    }, { signal }));
+                    config.app_id = await withEscBack(esc, (signal) => input({
+                        message: 'Honcho app ID:',
+                        theme: wizardInputTheme,
+                    }, { signal }));
+                    break;
+                }
+                case 'local-markdown': {
+                    const path = await withEscBack(esc, (signal) => input({
+                        default: provider.path,
+                        message: 'Markdown folder path:',
+                        theme: wizardInputTheme,
+                    }, { signal }));
+                    const name = await withEscBack(esc, (signal) => input({
+                        message: 'Human-readable name for this folder:',
+                        theme: wizardInputTheme,
+                    }, { signal }));
+                    config.folders = [{
+                            follow_wikilinks: true,
+                            name,
+                            path,
+                            read_only: true,
+                        }];
+                    break;
+                }
+                case 'obsidian': {
+                    config.vault_path = await withEscBack(esc, (signal) => input({
+                        default: provider.path,
+                        message: 'Obsidian vault path:',
+                        theme: wizardInputTheme,
+                    }, { signal }));
+                    break;
+                }
+            }
+            return config;
+        },
+        async confirmWrite(summary) {
+            console.log('\n' + chalk.bold('Memory Swarm Configuration Summary:'));
+            console.log(summary);
+            console.log('');
+            return withEscBack(esc, (signal) => confirm({
+                default: true,
+                message: 'Write to .brv/swarm/config.yaml?',
+            }, { signal }));
+        },
+        async selectProviders(detected) {
+            const choices = detected.map((p, index) => {
+                const status = p.detected
+                    ? chalk.green('detected')
+                    : chalk.dim('not found');
+                const detail = p.path ? ` — ${p.path}` : p.envVar ? ` (${p.envVar})` : '';
+                const count = p.noteCount ? ` (${p.noteCount} files)` : '';
+                return {
+                    checked: p.detected,
+                    disabled: p.id === 'byterover' ? '(always on)' : false,
+                    name: `${p.id}${detail}${count} [${status}]`,
+                    value: String(index),
+                };
+            });
+            return withEscBack(esc, (signal) => checkbox({
+                choices,
+                message: 'Select providers to enable:',
+                theme: wizardSelectTheme,
+            }, { signal }));
+        },
+    };
+}
+export default class SwarmOnboard extends Command {
+    static description = 'Set up memory swarm with interactive onboarding wizard';
+    static examples = [
+        '<%= config.bin %> swarm onboard',
+    ];
+    async run() {
+        this.log(chalk.bold('\nMemory Swarm Onboarding'));
+        this.log('Scanning for memory providers...\n');
+        const esc = createEscapeSignal();
+        try {
+            // Step 1: Detect providers
+            const detected = await detectProviders();
+            // Step 2: Run wizard
+            const prompts = createWizardPrompts(esc);
+            const answers = await runMemoryWizard(prompts, detected);
+            // Step 3: Scaffold config
+            const { warnings, yaml: configYaml } = scaffoldConfig(answers);
+            // Surface scaffolding warnings (e.g. duplicate vaults dropped)
+            for (const warning of warnings) {
+                this.log(chalk.yellow(`⚠ ${warning}`));
+            }
+            // Step 4: Write config file
+            const configDir = join(process.cwd(), '.brv', 'swarm');
+            if (!existsSync(configDir)) {
+                mkdirSync(configDir, { recursive: true });
+            }
+            const configPath = join(configDir, 'config.yaml');
+            writeFileSync(configPath, configYaml);
+            this.log(chalk.green(`\n✓ Config written to ${configPath}`));
+            // Step 5: Validate roundtrip
+            const parsed = load(configYaml);
+            const validation = safeValidateSwarmConfig(parsed);
+            if (validation.success) {
+                this.log(chalk.green('✓ Config validated successfully'));
+            }
+            else {
+                this.log(chalk.yellow('⚠ Config validation warning — check the generated file.'));
+            }
+            // Step 6: Suggest next step
+            this.log(`\nRun ${chalk.cyan('brv swarm status')} to verify provider health.`);
+        }
+        catch (error) {
+            if (error instanceof WizardCancelledError) {
+                this.log('\nWizard cancelled. No files were written.');
+                return;
+            }
+            if (isPromptCancelled(error)) {
+                this.log('\nWizard cancelled.');
+                return;
+            }
+            throw error;
+        }
+        finally {
+            esc.cleanup();
+        }
+    }
+}

package/dist/oclif/commands/swarm/query.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class SwarmQuery extends Command {
+    static args: {
+        query: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        explain: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'max-results': import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/oclif/commands/swarm/query.js

@@ -0,0 +1,84 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { FileSystemService } from '../../../agent/infra/file-system/file-system-service.js';
+import { formatQueryResults, formatQueryResultsExplain, formatQueryResultsJson } from '../../../agent/infra/swarm/cli/query-renderer.js';
+import { loadSwarmConfig } from '../../../agent/infra/swarm/config/swarm-config-loader.js';
+import { buildProvidersFromConfig } from '../../../agent/infra/swarm/provider-factory.js';
+import { SwarmCoordinator } from '../../../agent/infra/swarm/swarm-coordinator.js';
+import { validateSwarmProviders } from '../../../agent/infra/swarm/validation/config-validator.js';
+import { createSearchKnowledgeService } from '../../../agent/infra/tools/implementations/search-knowledge-service.js';
+export default class SwarmQuery extends Command {
+    static args = {
+        query: Args.string({ description: 'Natural language query to search across memory providers', required: true }),
+    };
+    static description = 'Query the memory swarm across all active providers';
+    static examples = [
+        '<%= config.bin %> swarm query "auth tokens"',
+        '<%= config.bin %> swarm query "what changed yesterday" --format json',
+    ];
+    static flags = {
+        explain: Flags.boolean({
+            description: 'Show classification, routing, and enrichment details (ignored with --format json, which always includes all metadata)',
+        }),
+        format: Flags.string({
+            char: 'f',
+            default: 'text',
+            description: 'Output format',
+            options: ['text', 'json'],
+        }),
+        'max-results': Flags.integer({
+            char: 'n',
+            description: 'Maximum number of results',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(SwarmQuery);
+        const isJson = flags.format === 'json';
+        try {
+            const config = await loadSwarmConfig(process.cwd());
+            // Build a real SearchKnowledgeService so ByteRover can search the context tree.
+            // FileSystemService is lightweight — safe to construct here for CLI use.
+            const workingDirectory = process.cwd();
+            const fileSystemService = new FileSystemService({ workingDirectory });
+            await fileSystemService.initialize();
+            const searchService = createSearchKnowledgeService(fileSystemService, {
+                baseDirectory: workingDirectory,
+            });
+            // Validate enrichment topology — structural errors block execution.
+            // Provider-specific errors (bad paths, missing API keys) are handled
+            // by health checks at runtime, preserving degraded-mode semantics.
+            const validation = await validateSwarmProviders(config);
+            const topologyErrors = validation.errors.filter((e) => e.provider === 'enrichment');
+            if (topologyErrors.length > 0) {
+                const messages = topologyErrors.map((e) => e.message);
+                throw new Error(`Invalid enrichment topology:\n  ${messages.join('\n  ')}`);
+            }
+            const providers = buildProvidersFromConfig(config, { searchService });
+            const coordinator = new SwarmCoordinator(providers, config);
+            // Run health checks so unhealthy providers are skipped
+            await coordinator.refreshHealth();
+            const result = await coordinator.execute({
+                maxResults: flags['max-results'],
+                query: args.query,
+            });
+            if (isJson) {
+                this.log(formatQueryResultsJson(result));
+            }
+            else if (flags.explain) {
+                this.log(formatQueryResultsExplain(result, args.query));
+            }
+            else {
+                this.log(formatQueryResults(result, args.query));
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (isJson) {
+                this.log(JSON.stringify({ error: message, success: false }));
+            }
+            else {
+                this.logToStderr(`Error: ${message}`);
+                this.exit(2);
+            }
+        }
+    }
+}

package/dist/oclif/commands/swarm/status.d.ts

@@ -0,0 +1,41 @@
+import { Command } from '@oclif/core';
+import { loadSwarmConfig } from '../../../agent/infra/swarm/config/swarm-config-loader.js';
+import { detectProviders } from '../../../agent/infra/swarm/wizard/provider-detector.js';
+type DetectedProviders = Awaited<ReturnType<typeof detectProviders>>;
+type SwarmConfig = Awaited<ReturnType<typeof loadSwarmConfig>>;
+/**
+ * Format enrichment edges for display.
+ */
+export declare function formatEnrichmentEdges(edges: Array<{
+    from: string;
+    to: string;
+}>): string[];
+/**
+ * Collect configured paths for path-based providers so we can detect
+ * newly discovered paths that aren't in the config yet.
+ */
+export declare function getConfiguredSwarmPaths(config: SwarmConfig): Set<string>;
+/**
+ * Build user-facing suggestions for detected providers that are not yet configured.
+ */
+export declare function findSwarmStatusSuggestions(config: SwarmConfig, detected: DetectedProviders): string[];
+export default class SwarmStatus extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private findSuggestions;
+    private renderCascadeNote;
+    private renderEnrichmentTopology;
+    private renderProviderLine;
+    private renderProviderStatusLines;
+    private renderSuggestionLines;
+    private renderSwarmSummary;
+    private renderTextOutput;
+    private renderValidationErrors;
+    private renderValidationWarnings;
+    private renderWriteTargets;
+}
+export {};