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

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

/**
 * View playbook patterns command
 */
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 { formatPlaybook } from '../formatters/playbook-formatter.js';
import chalk from 'chalk';
/**
 * View playbook patterns
 */
export async function patternsCommand(options) {
    const logger = new Logger(globalOptions);
    const spinner = logger.spinner('Fetching playbook...');
    try {
        const context = await createContext({ org: globalOptions.org, project: globalOptions.project });
        const client = new ACEServerClient(context, logger);
        // Fetch server config for defaults
        const serverConfig = await client.getConfig();
        const runtimeSettings = serverConfig?.runtime_settings || {};
        const effectiveSection = options.section ?? runtimeSettings.patternDefaultSection;
        const effectiveMinHelpful = options.minHelpful ?? runtimeSettings.patternMinHelpful ?? 0;
        logger.debug(`Patterns: section=${effectiveSection || 'all'}, min_helpful=${effectiveMinHelpful}`);
        const result = await client.getPlaybook({
            forceRefresh: false,
            include_metadata: true
        });
        spinner?.succeed('Playbook retrieved');
        // Apply client-side filtering
        let playbook = result.playbook;
        if (effectiveSection) {
            const emptyPlaybook = {
                strategies_and_hard_rules: [],
                useful_code_snippets: [],
                troubleshooting_and_pitfalls: [],
                apis_to_use: []
            };
            playbook = {
                ...emptyPlaybook,
                [effectiveSection]: playbook[effectiveSection] || []
            };
        }
        if (effectiveMinHelpful > 0) {
            for (const key of Object.keys(playbook)) {
                playbook[key] = playbook[key].filter((b) => (b.helpful || 0) >= effectiveMinHelpful);
            }
        }
        if (logger.isJson()) {
            logger.output({ playbook, total_bullets: result.total_bullets });
        }
        else {
            // Use total_bullets from server response (single source of truth)
            // NOTE: Object.keys(playbook).length is ALWAYS 4 (even when empty), so it's unreliable
            if (result.total_bullets === 0) {
                logger.warn('No patterns found');
                logger.stderr(chalk.dim('Run "ce-ace bootstrap" to initialize the playbook\n'));
                return;
            }
            formatPlaybook(playbook, {
                section: effectiveSection,
                minHelpful: effectiveMinHelpful,
                verbose: logger.isVerbose()
            });
            if (result.metadata && logger.isVerbose()) {
                logger.debug('Metadata:', result.metadata);
            }
        }
    }
    catch (error) {
        spinner?.fail('Failed to fetch playbook');
        logger.error('Failed to fetch playbook', error instanceof Error ? error : String(error));
        process.exit(1);
    }
}
//# sourceMappingURL=patterns.js.map