@ericnunes/frame-code-cli 0.0.1

package/dist/agent-runtime/registry/initialization.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeAgents = initializeAgents;
+exports.getDefaultAgent = getDefaultAgent;
+exports.listAgentsAvailable = listAgentsAvailable;
+const AgentRegistry_1 = require("./AgentRegistry");
+const logger_1 = require("../../infrastructure/logging/logger");
+async function initializeAgents() {
+    const registry = AgentRegistry_1.AgentRegistry.getInstance();
+    logger_1.logger.info('[Agents] Inicializando sistema de agentes...');
+    logger_1.logger.debug('[Agents] Diretório: .code/agents/');
+    const count = await registry.load();
+    if (count === 0) {
+        logger_1.logger.warn('[Agents] Nenhum agente encontrado em .code/agents/');
+        logger_1.logger.info('[Agents] Crie .code/agents/NOME_AGENTE/AGENT.md para definir novos agentes');
+    }
+    else {
+        const stats = registry.getStats();
+        logger_1.logger.info(`[Agents] ${count} agentes carregados:`);
+        logger_1.logger.info(`[Agents]   - Main agents: ${stats.mainAgents}`);
+        logger_1.logger.info(`[Agents]   - Sub agents: ${stats.subAgents}`);
+        logger_1.logger.info(`[Agents]   - Supervisores: ${stats.supervisors}`);
+    }
+    return count;
+}
+function getDefaultAgent(preferredAgent) {
+    const registry = AgentRegistry_1.AgentRegistry.getInstance();
+    if (preferredAgent && registry.has(preferredAgent)) {
+        return preferredAgent;
+    }
+    const mainAgents = registry.listByType('main-agent');
+    if (mainAgents.length > 0) {
+        return mainAgents[0].name;
+    }
+    throw new Error('Nenhum agente main-agent disponível');
+}
+function listAgentsAvailable() {
+    const registry = AgentRegistry_1.AgentRegistry.getInstance();
+    const agents = registry.listSummaries();
+    if (agents.length === 0) {
+        return 'Nenhum agente disponível.';
+    }
+    const lines = ['Agentes Disponíveis:', ''];
+    for (const agent of agents) {
+        const typeLabel = agent.type === 'main-agent' ? '[MAIN]' : '[SUB]';
+        const supervisorLabel = agent.canBeSupervisor ? ' [SUPERVISOR]' : '';
+        const keywords = agent.keywords.length > 0
+            ? ' (keywords: ' + agent.keywords.join(', ') + ')'
+            : '';
+        lines.push('  ' + typeLabel + supervisorLabel + ' ' + agent.name + ': ' + agent.description + keywords);
+    }
+    return lines.join('\n');
+}

package/dist/agent-runtime/registry/interfaces/agentDependencies.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/agent-runtime/registry/interfaces/agentMetadata.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/agent-runtime/registry/interfaces/agentRegistry.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/app/bootstrap.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bootstrap = bootstrap;
+exports.createDefaultTelemetry = createDefaultTelemetry;
+const config_1 = require("../infrastructure/config");
+const logger_1 = require("../infrastructure/logging/logger");
+const tools_1 = require("../tools");
+const agent_runtime_1 = require("../agent-runtime");
+const telemetry_1 = require("../infrastructure/telemetry");
+async function bootstrap() {
+    logger_1.logger.info('[Bootstrap] Inicializando frame-code-cli...');
+    await (0, config_1.loadConfig)();
+    logger_1.logger.debug('[Bootstrap] Configuração carregada');
+    await (0, tools_1.initializeTools)();
+    logger_1.logger.debug('[Bootstrap] Ferramentas inicializadas');
+    const agentCount = await (0, agent_runtime_1.initializeAgents)();
+    logger_1.logger.info(`[Bootstrap] ${agentCount} agentes carregados`);
+    logger_1.logger.info('[Bootstrap] Inicialização concluída');
+}
+function createDefaultTelemetry() {
+    return (0, telemetry_1.createCliTelemetry)();
+}

package/dist/app/cli.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.program = void 0;
+exports.runCli = runCli;
+const commander_1 = require("commander");
+const interactive_1 = require("../cli/commands/interactive");
+const autonomous_1 = require("../cli/commands/autonomous");
+const memory_1 = require("../cli/commands/memory");
+const multi_agent_1 = require("../cli/commands/multi-agent");
+exports.program = new commander_1.Command()
+    .name('frame-code-cli')
+    .description('CLI para frame-code com agentes')
+    .version('0.0.1');
+exports.program.addCommand(interactive_1.interactiveCommand);
+exports.program.addCommand((0, autonomous_1.createAutonomousCommand)());
+exports.program.addCommand(memory_1.memoryCommand);
+exports.program.addCommand((0, multi_agent_1.createMultiAgentCommand)());
+function runCli(argv = process.argv) {
+    try {
+        const nextArgv = [...argv];
+        if (nextArgv.length <= 2) {
+            nextArgv.push('interactive');
+        }
+        exports.program.parse(nextArgv);
+    }
+    catch (error) {
+        console.error('Erro:', error);
+        process.exit(1);
+    }
+}

package/dist/app/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultTelemetry = exports.bootstrap = exports.program = exports.runCli = void 0;
+var cli_1 = require("./cli");
+Object.defineProperty(exports, "runCli", { enumerable: true, get: function () { return cli_1.runCli; } });
+Object.defineProperty(exports, "program", { enumerable: true, get: function () { return cli_1.program; } });
+var bootstrap_1 = require("./bootstrap");
+Object.defineProperty(exports, "bootstrap", { enumerable: true, get: function () { return bootstrap_1.bootstrap; } });
+Object.defineProperty(exports, "createDefaultTelemetry", { enumerable: true, get: function () { return bootstrap_1.createDefaultTelemetry; } });

package/dist/cli/commands/autonomous.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAutonomousInput = processAutonomousInput;
+exports.createAutonomousCommand = createAutonomousCommand;
+const commander_1 = require("commander");
+const fs_1 = require("fs");
+const logger_1 = require("../../infrastructure/logging/logger");
+const frame_agent_sdk_1 = require("@ericnunes/frame-agent-sdk");
+const tools_1 = require("../../tools");
+const config_1 = require("../../infrastructure/config");
+const reader_1 = require("../input/reader");
+const telemetry_1 = require("../../infrastructure/telemetry");
+const attachments_1 = require("../input/images/attachments");
+const agent_runtime_1 = require("../../agent-runtime");
+async function processAutonomousInput(input, options) {
+    try {
+        logger_1.logger.info('[Autonomous] Iniciando processamento autônomo');
+        if (options.verbose) {
+            logger_1.logger.info(`[Autonomous] Input recebido: ${input.substring(0, 200)}...`);
+        }
+        const { trace, telemetry } = (0, telemetry_1.createCliTelemetry)();
+        const registry = agent_runtime_1.AgentRegistry.getInstance();
+        let agentName;
+        if (options.agent) {
+            if (!registry.has(options.agent)) {
+                throw new Error(`Agente "${options.agent}" não encontrado. Agentes disponíveis: ${registry.listSummaries().map(a => a.name).join(', ')}`);
+            }
+            const agent = registry.getMetadata(options.agent);
+            if (agent?.type !== 'main-agent') {
+                throw new Error(`Agente "${options.agent}" é do tipo "sub-agent" e não pode ser usado diretamente. Use um main-agent: ${registry.listByType('main-agent').map(a => a.name).join(', ')}`);
+            }
+            agentName = options.agent;
+            logger_1.logger.info(`[Autonomous] Usando agente especificado: ${agentName}`);
+        }
+        else {
+            agentName = (0, agent_runtime_1.getDefaultAgent)('code-agent');
+            logger_1.logger.info(`[Autonomous] Usando agente padrão: ${agentName}`);
+        }
+        const graph = await registry.createEngine(agentName, {
+            trace,
+            telemetry
+        });
+        const imagePaths = options._imagePaths ?? [];
+        const imageDetail = options.imageDetail ?? 'auto';
+        const imageHint = imagePaths.length > 0
+            ? `Imagens disponiveis (paths locais):\n${imagePaths.map((p) => `- ${p}`).join('\n')}\n\nSe precisar enxergar, chame a tool read_image com source=\"path\" e path do arquivo.`
+            : '';
+        const messages = [];
+        if (imageHint && imageHint.trim().length > 0) {
+            messages.push({ role: 'system', content: imageHint });
+        }
+        messages.push({ role: 'user', content: input });
+        logger_1.logger.debug('[Autonomous] Mensagens iniciais:', JSON.stringify(messages, null, 2));
+        const initialState = {
+            messages,
+            data: {
+                ...(options._runId ? { runId: options._runId } : {}),
+                ...(imagePaths.length ? { imagePaths, imageDetail } : {})
+            },
+            status: frame_agent_sdk_1.GraphStatus.RUNNING
+        };
+        const result = await graph.execute(initialState);
+        logger_1.logger.debug(`[Autonomous] Status final: ${result.status}`);
+        logger_1.logger.debug(`[Autonomous] lastToolCall:`, result.state.lastToolCall);
+        if (result.status === frame_agent_sdk_1.GraphStatus.ERROR) {
+            throw new Error(`Erro durante execução: ${result.state.logs?.join('\n') || 'Erro desconhecido'}`);
+        }
+        if (result.status !== frame_agent_sdk_1.GraphStatus.FINISHED) {
+            logger_1.logger.warn(`[Autonomous] Status não finalizado: ${result.status}`);
+            return 'Processamento concluído com status: ' + result.status;
+        }
+        const lastToolCall = result.state.lastToolCall;
+        if (lastToolCall?.toolName === 'final_answer') {
+            const answer = lastToolCall?.params?.answer;
+            if (typeof answer === 'string' && answer.trim().length > 0) {
+                return answer;
+            }
+        }
+        const lastAssistantMessage = result.state.messages
+            .filter((msg) => msg.role === 'assistant')
+            .pop();
+        return lastAssistantMessage?.content || 'Processamento concluído sem resposta';
+    }
+    catch (error) {
+        logger_1.logger.error('[Autonomous] Erro no processamento:', error);
+        throw error;
+    }
+}
+function createAutonomousCommand() {
+    const command = new commander_1.Command('autonomous');
+    const collect = (value, previous) => {
+        return [...(previous ?? []), value];
+    };
+    command
+        .description('Executar frame-code-cli em modo autônomo sem interação humana')
+        .argument('[agent]', 'Agente a ser usado (ex: supervisor, code-agent, chrome-mcp-agent)')
+        .argument('[additional-input]', 'Texto adicional com prioridade sobre o arquivo de entrada')
+        .option('-i, --input-file <file>', 'Arquivo de entrada com o prompt')
+        .option('-o, --output-file <file>', 'Arquivo de saída para a resposta')
+        .option('-l, --log-file <file>', 'Arquivo de log detalhado')
+        .option('-v, --verbose', 'Modo verboso com logs detalhados')
+        .option('-a, --agent <name>', 'Agente a ser usado (alternativa ao argumento posicional)')
+        .option('--image <path>', 'Caminho de imagem local (pode repetir)', collect, [])
+        .option('--image-detail <low|high|auto>', 'Nivel de detalhe para imagem (low|high|auto)', 'auto')
+        .action(async (agentArg, additionalInput, options) => {
+        try {
+            await (0, config_1.loadConfig)();
+            await (0, tools_1.initializeTools)();
+            await (0, agent_runtime_1.initializeAgents)();
+            const registry = agent_runtime_1.AgentRegistry.getInstance();
+            let resolvedAgent = options.agent;
+            let resolvedInput = additionalInput;
+            if (!resolvedAgent && agentArg) {
+                const agentMetadata = registry.getMetadata(agentArg);
+                if (agentMetadata && agentMetadata.type === 'main-agent') {
+                    resolvedAgent = agentArg;
+                }
+                else {
+                    resolvedInput = agentArg;
+                }
+            }
+            if (resolvedAgent && !resolvedInput && agentArg) {
+                resolvedInput = agentArg;
+            }
+            if (resolvedAgent) {
+                options.agent = resolvedAgent;
+            }
+            const input = await (0, reader_1.readCliInput)({ inputFile: options.inputFile, additionalInput: resolvedInput });
+            if (!input || input.trim().length === 0) {
+                throw new Error('Input vazio. Forneça uma tarefa para executar.');
+            }
+            if (options.image && options.image.length > 0) {
+                await (0, attachments_1.cleanupAttachmentsRoot)((0, attachments_1.getAttachmentsCleanupConfigFromEnv)());
+                const staged = await (0, attachments_1.stageImageAttachments)({ imagePaths: options.image });
+                options._runId = staged.runId;
+                options._imagePaths = staged.stagedPaths;
+            }
+            if (options.agent) {
+                logger_1.logger.info(`[Autonomous] Usando agente: ${options.agent}`);
+            }
+            else {
+                logger_1.logger.info(`[Autonomous] Usando agente padrão`);
+            }
+            if (resolvedInput) {
+                logger_1.logger.info(`[Autonomous] Input prioritário: ${resolvedInput.substring(0, 100)}...`);
+            }
+            logger_1.logger.debug('[Autonomous] Iniciando processamento do input');
+            logger_1.logger.debug(`[Autonomous] Input: "${input.substring(0, 200)}"`);
+            const result = await processAutonomousInput(input, options);
+            logger_1.logger.debug(`[Autonomous] Processamento concluído, resultado: ${result.substring(0, 50)}...`);
+            if (options.outputFile) {
+                logger_1.logger.info(`[Autonomous] Escrevendo output em: ${options.outputFile}`);
+                (0, fs_1.writeFileSync)(options.outputFile, result, 'utf-8');
+            }
+            else {
+                logger_1.logger.debug('[Autonomous] Imprimindo resultado no console');
+                console.log(result);
+            }
+            if (options.logFile) {
+                const logContent = 'Logs detalhados não implementados';
+                (0, fs_1.writeFileSync)(options.logFile, logContent, 'utf-8');
+            }
+            logger_1.logger.info('[Autonomous] Processamento autônomo concluído com sucesso');
+            process.exit(0);
+        }
+        catch (error) {
+            logger_1.logger.error('[Autonomous] Erro fatal:', error);
+            const errorMessage = error instanceof Error ? error.message : 'Erro desconhecido';
+            if (options.outputFile) {
+                logger_1.logger.debug(`[Autonomous] Escrevendo erro no arquivo: ${options.outputFile}`);
+                (0, fs_1.writeFileSync)(options.outputFile, `## Erro durante processamento\n\n${errorMessage}`, 'utf-8');
+            }
+            else {
+                logger_1.logger.debug('[Autonomous] Imprimindo erro no console');
+                console.error('Erro:', errorMessage);
+            }
+            process.exit(1);
+        }
+    });
+    return command;
+}

package/dist/cli/commands/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMemoryCommand = exports.createMultiAgentCommand = exports.createInteractiveCommand = exports.createAutonomousCommand = void 0;
+var autonomous_1 = require("./autonomous");
+Object.defineProperty(exports, "createAutonomousCommand", { enumerable: true, get: function () { return autonomous_1.createAutonomousCommand; } });
+var interactive_1 = require("./interactive");
+Object.defineProperty(exports, "createInteractiveCommand", { enumerable: true, get: function () { return interactive_1.createInteractiveCommand; } });
+var multi_agent_1 = require("./multi-agent");
+Object.defineProperty(exports, "createMultiAgentCommand", { enumerable: true, get: function () { return multi_agent_1.createMultiAgentCommand; } });
+var memory_1 = require("./memory");
+Object.defineProperty(exports, "createMemoryCommand", { enumerable: true, get: function () { return memory_1.createMemoryCommand; } });

package/dist/cli/commands/interactive.js

@@ -0,0 +1,172 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interactiveCommand = void 0;
+exports.createInteractiveCommand = createInteractiveCommand;
+const commander_1 = require("commander");
+const readline = __importStar(require("readline"));
+const logger_1 = require("../../infrastructure/logging/logger");
+const frame_agent_sdk_1 = require("@ericnunes/frame-agent-sdk");
+const tools_1 = require("../../tools");
+const config_1 = require("../../infrastructure/config");
+const telemetry_1 = require("../../infrastructure/telemetry");
+const attachments_1 = require("../input/images/attachments");
+const agent_runtime_1 = require("../../agent-runtime");
+let interactiveExecuted = false;
+function createInteractiveCommand() {
+    const command = new commander_1.Command('interactive');
+    command
+        .description('Iniciar modo interativo')
+        .option('--agent <name>', 'Agente a usar (ex: supervisor, chrome-mcp-agent, code-agent)', 'chrome-mcp-agent')
+        .option('--image <path>', 'Caminho de imagem local (pode repetir)', (value, previous) => [...(previous ?? []), value], [])
+        .option('--image-detail <low|high|auto>', 'Nivel de detalhe para imagem (low|high|auto)', 'auto')
+        .action(async (options) => {
+        try {
+            if (interactiveExecuted) {
+                return;
+            }
+            interactiveExecuted = true;
+            await (0, config_1.loadConfig)();
+            console.log('.frame-agent CLI');
+            console.log('==============================================');
+            console.log('Modo Chat Interativo');
+            console.log('Dica: Digite suas perguntas ou "sair" para encerrar');
+            console.log('');
+            let imagePaths = [];
+            let runId;
+            const imageDetail = options?.imageDetail ?? 'auto';
+            if (options?.image && options.image.length > 0) {
+                await (0, attachments_1.cleanupAttachmentsRoot)((0, attachments_1.getAttachmentsCleanupConfigFromEnv)());
+                const staged = await (0, attachments_1.stageImageAttachments)({ imagePaths: options.image });
+                runId = staged.runId;
+                imagePaths = staged.stagedPaths;
+            }
+            const imageHint = imagePaths.length > 0
+                ? `Imagens disponiveis (paths locais):\n${imagePaths.map((p) => `- ${p}`).join('\n')}\n\nSe precisar enxergar, chame a tool read_image com source=\"path\" e path do arquivo.`
+                : '';
+            let currentState = {
+                messages: [...(imageHint ? [{ role: 'system', content: imageHint }] : [])],
+                data: {
+                    ...(runId ? { runId } : {}),
+                    ...(imagePaths.length ? { imagePaths, imageDetail } : {}),
+                },
+                status: frame_agent_sdk_1.GraphStatus.RUNNING
+            };
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            console.log('Inicializando ferramentas...');
+            await (0, tools_1.initializeTools)();
+            console.log('Inicializando agente...');
+            const { trace, telemetry } = (0, telemetry_1.createCliTelemetry)();
+            const registry = agent_runtime_1.AgentRegistry.getInstance();
+            const agentName = (0, agent_runtime_1.getDefaultAgent)(options?.agent);
+            const graph = await registry.createEngine(agentName, {
+                trace,
+                telemetry
+            });
+            console.log('Agente pronto!');
+            console.log('');
+            const processQuestion = async (question) => {
+                try {
+                    const newState = {
+                        messages: [...currentState.messages, { role: 'user', content: question }],
+                        data: { ...currentState.data },
+                        status: frame_agent_sdk_1.GraphStatus.RUNNING
+                    };
+                    console.log('Processando...');
+                    const result = await graph.execute(newState);
+                    currentState.messages = result.state.messages;
+                    currentState.data = result.state.data;
+                    currentState.status = result.state.status;
+                    if (result.status === frame_agent_sdk_1.GraphStatus.FINISHED) {
+                    }
+                    else if (result.status === frame_agent_sdk_1.GraphStatus.ERROR) {
+                        console.log('\n❌ Erro na execução: ' + (currentState.logs?.join('\n') || 'Erro desconhecido'));
+                    }
+                }
+                catch (error) {
+                    logger_1.logger.error('Erro no processamento da questão:', error);
+                    console.log('\n❌ Ocorreu um erro ao processar sua solicitação.');
+                }
+            };
+            let promptActive = false;
+            const showPrompt = () => {
+                if (promptActive) {
+                    return;
+                }
+                promptActive = true;
+                rl.question('Você: ', async (input) => {
+                    promptActive = false;
+                    const trimmedInput = input.trim();
+                    if (trimmedInput.toLowerCase() === 'sair' ||
+                        trimmedInput.toLowerCase() === 'exit' ||
+                        trimmedInput.toLowerCase() === 'quit') {
+                        console.log('Até mais! Obrigado por usar o frame-agent.');
+                        rl.close();
+                        return;
+                    }
+                    if (trimmedInput === '') {
+                        showPrompt();
+                        return;
+                    }
+                    try {
+                        await processQuestion(trimmedInput);
+                    }
+                    catch (error) {
+                        logger_1.logger.error('Erro em processQuestion:', error);
+                    }
+                    console.log('\n' + '='.repeat(50) + '\n');
+                    showPrompt();
+                });
+            };
+            console.log('Bem-vindo ao Chat frame-agent! Como posso ajudar?');
+            showPrompt();
+            rl.on('close', () => {
+                console.log('\nSessão encerrada. Até a próxima!');
+                process.exit(0);
+            });
+            rl.removeAllListeners('line');
+            rl.removeAllListeners('question');
+        }
+        catch (error) {
+            logger_1.logger.error('Erro ao iniciar modo interativo:', error);
+            process.exit(1);
+        }
+    });
+    return command;
+}
+exports.interactiveCommand = createInteractiveCommand();

package/dist/cli/commands/memory.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryCommand = void 0;
+exports.createMemoryCommand = createMemoryCommand;
+const commander_1 = require("commander");
+const compression_1 = require("../../infrastructure/compression");
+const logger_1 = require("../../infrastructure/logging/logger");
+const config_1 = require("../../infrastructure/config");
+function createMemoryStatusCommand() {
+    const command = new commander_1.Command('status');
+    command
+        .description('Mostrar status atual da memória e compressão')
+        .action(async () => {
+        try {
+            const config = await (0, config_1.loadConfig)();
+            if (!config.compression?.enabled) {
+                console.log('❌ Compressão de memória está desabilitada');
+                console.log('💡 Habilite com COMPRESSION_ENABLED=true no .env');
+                return;
+            }
+            const compressionManager = new compression_1.CompressionManager(config.compression);
+            const stats = compressionManager.getCompressionStats();
+            console.log('📊 Status da Memória e Compressão');
+            console.log('='.repeat(40));
+            console.log(`✅ Compressão: ${stats.enabled ? 'Habilitada' : 'Desabilitada'}`);
+            console.log(`📈 Threshold: ${(stats.threshold * 100).toFixed(0)}%`);
+            console.log(`🔄 Compressões atuais: ${stats.currentCompressions}/${stats.maxCompressions}`);
+            console.log(`📝 Total de compressões realizadas: ${stats.compressionCount}`);
+            console.log(`💾 Persistência: ${config.compression.persist ? 'Habilitada' : 'Desabilitada'}`);
+            console.log(`📊 Logging: ${config.compression.logging ? 'Habilitado' : 'Desabilitado'}`);
+            if (stats.compressionHistory.length > 0) {
+                console.log('\n📜 Histórico de Compressões:');
+                stats.compressionHistory.forEach((comp, index) => {
+                    console.log(`  ${index + 1}. ${comp.preview} (${comp.length} caracteres)`);
+                });
+            }
+            else {
+                console.log('\n📜 Nenhuma compressão realizada ainda');
+            }
+        }
+        catch (error) {
+            logger_1.logger.error('[MemoryCommand] Erro ao obter status:', error);
+            console.error('❌ Erro ao obter status da memória');
+        }
+    });
+    return command;
+}
+function createMemoryCompressCommand() {
+    const command = new commander_1.Command('compress');
+    command
+        .description('Forçar compressão manual da memória')
+        .action(async () => {
+        try {
+            const config = await (0, config_1.loadConfig)();
+            if (!config.compression?.enabled) {
+                console.log('❌ Compressão de memória está desabilitada');
+                console.log('💡 Habilite com COMPRESSION_ENABLED=true no .env');
+                return;
+            }
+            console.log('🔄 Iniciando compressão manual...');
+            const compressionManager = new compression_1.CompressionManager(config.compression);
+            const statsBefore = compressionManager.getCompressionStats();
+            console.log(`📊 Antes: ${statsBefore.currentCompressions}/${statsBefore.maxCompressions} compressões`);
+            console.log('💡 Para compressão manual during conversa, use o modo interativo');
+            console.log('   A compressão automática ocorrerá quando necessário');
+        }
+        catch (error) {
+            logger_1.logger.error('[MemoryCommand] Erro na compressão manual:', error);
+            console.error('❌ Erro na compressão manual');
+        }
+    });
+    return command;
+}
+function createMemoryClearCommand() {
+    const command = new commander_1.Command('clear');
+    command
+        .description('Limpar todo o histórico de compressões')
+        .action(async () => {
+        try {
+            const config = await (0, config_1.loadConfig)();
+            if (!config.compression?.enabled) {
+                console.log('❌ Compressão de memória está desabilitada');
+                return;
+            }
+            const compressionManager = new compression_1.CompressionManager(config.compression);
+            const statsBefore = compressionManager.getCompressionStats();
+            if (statsBefore.currentCompressions === 0) {
+                console.log('📝 Não há compressões para limpar');
+                return;
+            }
+            console.log(`🗑️ Limpando ${statsBefore.currentCompressions} compressões...`);
+            compressionManager.clearCompressions();
+            console.log('✅ Histórico de compressões limpo com sucesso');
+            console.log('💾 Arquivo de persistência removido (se existia)');
+        }
+        catch (error) {
+            logger_1.logger.error('[MemoryCommand] Erro ao limpar compressões:', error);
+            console.error('❌ Erro ao limpar compressões');
+        }
+    });
+    return command;
+}
+function createMemoryConfigCommand() {
+    const command = new commander_1.Command('config');
+    command
+        .description('Mostrar configuração atual de compressão')
+        .action(async () => {
+        try {
+            const config = await (0, config_1.loadConfig)();
+            console.log('⚙️ Configuração de Compressão');
+            console.log('='.repeat(30));
+            if (!config.compression) {
+                console.log('❌ Nenhuma configuração de compressão encontrada');
+                return;
+            }
+            console.log(`enabled: ${config.compression.enabled}`);
+            console.log(`threshold: ${config.compression.threshold} (${(config.compression.threshold * 100).toFixed(0)}%)`);
+            console.log(`maxCount: ${config.compression.maxCount}`);
+            console.log(`maxTokens: ${config.compression.maxTokens}`);
+            console.log(`model: ${config.compression.model || 'padrão do LLM'}`);
+            console.log(`logging: ${config.compression.logging}`);
+            console.log(`persist: ${config.compression.persist}`);
+            console.log('\n📝 Variáveis de ambiente correspondentes:');
+            console.log('COMPRESSION_ENABLED');
+            console.log('COMPRESSION_THRESHOLD');
+            console.log('COMPRESSION_MAX_COUNT');
+            console.log('COMPRESSION_MAX_TOKENS');
+            console.log('COMPRESSION_MODEL');
+            console.log('COMPRESSION_LOGGING');
+            console.log('COMPRESSION_PERSIST');
+        }
+        catch (error) {
+            logger_1.logger.error('[MemoryCommand] Erro ao mostrar configuração:', error);
+            console.error('❌ Erro ao mostrar configuração');
+        }
+    });
+    return command;
+}
+function createMemoryCommand() {
+    const command = new commander_1.Command('memory');
+    command
+        .description('Gerenciar memória e compressão da CLI');
+    command.addCommand(createMemoryStatusCommand());
+    command.addCommand(createMemoryCompressCommand());
+    command.addCommand(createMemoryClearCommand());
+    command.addCommand(createMemoryConfigCommand());
+    return command;
+}
+exports.memoryCommand = createMemoryCommand();