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

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

/**
 * Cache management command
 */
import { globalOptions } from '../cli.js';
import { createContext } from '../types/config.js';
import { ACEServerClient } from '../services/server-client.js';
import { SessionStorage } from '../services/session-storage.js';
import { Logger } from '../services/logger.js';
import chalk from 'chalk';
/**
 * Clear local cache
 */
export async function cacheCommand(options) {
    const logger = new Logger(globalOptions);
    const spinner = logger.spinner('Clearing cache...');
    try {
        const context = await createContext({ org: globalOptions.org, project: globalOptions.project });
        const client = new ACEServerClient(context, logger);
        // The client only has invalidateCache() which clears all caches
        client.invalidateCache();
        spinner?.succeed('Cache cleared');
        if (logger.isJson()) {
            logger.output({
                success: true,
                message: `Cache cleared (type: ${options.type || 'all'})`
            });
        }
        else {
            logger.info(chalk.green(`\n✅ ${options.type || 'all'} cache cleared successfully\n`));
        }
    }
    catch (error) {
        spinner?.fail('Failed to clear cache');
        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);
    }
}
/**
 * Recall patterns from a pinned session
 */
export async function cacheRecallCommand(options) {
    const logger = new Logger(globalOptions);
    if (!options.session) {
        if (logger.isJson()) {
            logger.output({ error: 'Session ID is required' });
        }
        else {
            logger.error(chalk.red('Error: Session ID is required (--session <sessionId>)'));
        }
        process.exit(1);
    }
    const spinner = logger.spinner('Recalling session...');
    try {
        const sessionStorage = new SessionStorage(logger);
        await sessionStorage.initialize();
        const result = await sessionStorage.recallSession(options.session);
        if (!result) {
            spinner?.fail('Session not found or expired');
            if (logger.isJson()) {
                logger.output({
                    error: 'Session not found or expired',
                    session_id: options.session
                });
            }
            else {
                logger.error(chalk.red(`\nError: Session "${options.session}" not found or expired\n`));
                logger.info(chalk.dim('Sessions expire after 24 hours\n'));
            }
            process.exit(1);
        }
        sessionStorage.close();
        spinner?.succeed(`Recalled ${result.count} patterns from session`);
        if (logger.isJson()) {
            logger.output(result);
        }
        else {
            logger.info(chalk.green(`\n✅ Recalled ${result.count} patterns from session: ${options.session}\n`));
            logger.info(chalk.dim(`Query: ${result.similar_patterns[0]?.content.substring(0, 60)}...\n`));
            logger.info(chalk.dim(`Threshold: ${result.threshold}`));
            logger.info(chalk.dim(`Top-K: ${result.top_k}`));
            logger.info(chalk.dim(`Pinned: ${new Date(result.pinned_at).toLocaleString()}`));
            logger.info(chalk.dim(`Expires: ${new Date(result.expires_at).toLocaleString()}\n`));
        }
    }
    catch (error) {
        spinner?.fail('Failed to recall session');
        if (logger.isJson()) {
            logger.output({ error: error instanceof Error ? error.message : String(error) });
        }
        else {
            logger.error(chalk.red(`\nError: ${error instanceof Error ? error.message : String(error)}\n`));
        }
        process.exit(1);
    }
}
//# sourceMappingURL=cache.js.map