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

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

/**
 * Import playbook command
 */
import { readFileSync } from 'fs';
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';
/**
 * Import playbook from JSON file or stdin
 */
export async function importCommand(fileArg, options) {
    const logger = new Logger(globalOptions);
    const spinner = logger.spinner('Importing playbook...');
    try {
        let playbook;
        // Read from stdin if specified
        if (options.stdin) {
            const stdinData = readFileSync(0, 'utf8'); // fd 0 is stdin
            playbook = JSON.parse(stdinData.trim());
        }
        // Read from file (either from --file option or positional argument)
        else {
            const file = options.file || fileArg;
            if (!file) {
                throw new Error('Must provide either a file path or use --stdin');
            }
            const fileContent = readFileSync(file, 'utf8');
            playbook = JSON.parse(fileContent);
        }
        const context = await createContext({ org: globalOptions.org, project: globalOptions.project });
        const client = new ACEServerClient(context, logger);
        // Convert playbook to code blocks for bootstrap
        const codeBlocks = [];
        // Add all patterns from each section
        if (playbook.strategies_and_hard_rules) {
            for (const pattern of playbook.strategies_and_hard_rules) {
                codeBlocks.push(`[STRATEGY] ${pattern.content}`);
            }
        }
        if (playbook.useful_code_snippets) {
            for (const pattern of playbook.useful_code_snippets) {
                codeBlocks.push(pattern.content);
            }
        }
        if (playbook.troubleshooting_and_pitfalls) {
            for (const pattern of playbook.troubleshooting_and_pitfalls) {
                codeBlocks.push(`[TROUBLESHOOTING] ${pattern.content}`);
            }
        }
        if (playbook.apis_to_use) {
            for (const pattern of playbook.apis_to_use) {
                codeBlocks.push(`[API] ${pattern.content}`);
            }
        }
        // Import via bootstrap
        await client.bootstrap({
            mode: 'local-files',
            code_blocks: codeBlocks,
            metadata: {
                blocks_extracted: codeBlocks.length
            }
        });
        // Invalidate cache
        client.invalidateCache();
        spinner?.succeed('Playbook imported');
        const source = options.stdin ? 'stdin' : (options.file || fileArg);
        if (logger.isJson()) {
            logger.output({ success: true, message: 'Playbook imported', source });
        }
        else {
            logger.info(chalk.green(`\n✅ Playbook imported successfully from ${source}\n`));
        }
    }
    catch (error) {
        spinner?.fail('Failed to import playbook');
        if (logger.isJson()) {
            logger.output({ error: error instanceof Error ? error.message : String(error) });
        }
        else {
            logger.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
        }
        process.exit(1);
    }
}
//# sourceMappingURL=import.js.map