@ace-sdk/cli/dist/commands/domains.js

ACE CLI - Command-line tool for intelligent pattern learning and playbook management

/**
 * Domains Command - List available pattern domains
 *
 * Lists all domains from the server's by_domain statistics,
 * enabling users to discover valid domain names for filtering
 * ace search with --allowed-domains or --blocked-domains.
 *
 * @package @ace-sdk/cli
 */
import { globalOptions } from '../cli.js';
import { createContext } from '../types/config.js';
import { ACEServerClient } from '../services/server-client.js';
import { Logger } from '../services/logger.js';
import chalk from 'chalk';
export async function domainsCommand(options) {
    const logger = new Logger(globalOptions);
    let spinner = logger.spinner('Fetching available domains...');
    try {
        // Create context using 4-tier precedence (flags > env > .claude/settings.json > error)
        const context = await createContext({ org: globalOptions.org, project: globalOptions.project });
        const client = new ACEServerClient(context, logger);
        const minPatterns = options.minPatterns ?? 1;
        const status = await client.getAnalytics();
        const byDomain = status.by_domain || {};
        // Filter and sort domains
        const domains = Object.entries(byDomain)
            .filter(([_, count]) => count >= minPatterns)
            .map(([name, count]) => ({ name, count }))
            .sort((a, b) => b.count - a.count);
        const totalPatterns = Object.values(byDomain).reduce((a, b) => a + b, 0);
        spinner?.succeed('Domains retrieved');
        if (logger.isJson()) {
            logger.output({
                domains,
                total_domains: domains.length,
                total_patterns: totalPatterns
            });
            return;
        }
        if (domains.length === 0) {
            logger.info(chalk.yellow('\nNo domains found with patterns.'));
            logger.info(chalk.dim('Run ce-ace bootstrap or ce-ace learn to create patterns.\n'));
            return;
        }
        // Header
        logger.info('');
        logger.info(chalk.bold(`📊 ${domains.length} Domains (${totalPatterns} total patterns)`));
        logger.info(chalk.dim('─'.repeat(60)));
        // Domain list with visual bar chart
        const maxNameLen = Math.max(...domains.map(d => d.name.length));
        const maxCount = Math.max(...domains.map(d => d.count));
        for (const domain of domains) {
            const paddedName = domain.name.padEnd(maxNameLen);
            const barLen = Math.ceil((domain.count / maxCount) * 20);
            const bar = '█'.repeat(barLen);
            logger.info(`  ${chalk.cyan(paddedName)}  ${chalk.dim(domain.count.toString().padStart(3))} ${chalk.green(bar)}`);
        }
        logger.info('');
        logger.info(chalk.dim('Usage with search:'));
        logger.info(chalk.dim(`  ce-ace search "query" --allowed-domains "${domains[0]?.name || 'domain-name'}"`));
        logger.info(chalk.dim(`  ce-ace search "query" --blocked-domains "${domains[0]?.name || 'domain-name'}"`));
        logger.info('');
    }
    catch (error) {
        spinner?.fail('Failed to fetch domains');
        if (logger.isJson()) {
            logger.error(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
        }
        else {
            logger.error(chalk.red(`\n❌ Error: ${error instanceof Error ? error.message : String(error)}\n`));
        }
        process.exit(1);
    }
}
//# sourceMappingURL=domains.js.map