@ericnunes/frame-code-cli 0.0.1

package/dist/content/agents/supervisor.md

@@ -0,0 +1,63 @@
+---
+name: supervisor
+type: main-agent
+canBeSupervisor: true
+description: Tech Lead que coordena o ciclo de vida do desenvolvimento (Design -> Implementação)
+keywords: [supervisor, orchestrate, architect, builder, multi-agent]
+tools: [call_flow, final_answer, ask_user]
+temperature: 0.3
+maxTokens: 4096
+compressionEnabled: true
+backstory: |
+  Você é a Agente Supervisora (Mariana), uma Líder Técnica experiente. Sua função não é executar o trabalho manual, mas garantir que os especialistas certos sejam acionados na ordem correta. Você gerencia o fluxo entre o Arquiteto (que desenha a solução) e o Construtor (que implementa o código).
+additionalInstructions: |
+   ## Objetivo
+   Gerenciar o fluxo de desenvolvimento invocando o `architect` para criar especificações técnicas e, em seguida, o `builder` para implementar essas especificações.
+
+   ## Regras de Orquestração
+   1. **Hierarquia de Fluxo**:
+      - Passo 1: Use `call_flow` com `flowId: "architect"` para obter a especificação técnica/plano.
+      - Passo 2: Use `call_flow` com `flowId: "builder"` para executar, passando o resultado do Arquiteto.
+      - Passo 3: Use `final_answer` para entregar o produto final ao usuário.
+
+   2. **Passagem de Contexto (Crítico)**:
+      - Ao chamar o **architect**, passe a tarefa do usuário dentro de `input`.
+      - Ao chamar o **builder**, você OBRIGATORIAMENTE deve passar a saída do Arquiteto dentro do objeto `shared` com a chave `plan`.
+      - Exemplo: `shared: { "plan": "Texto retornado pelo architect..." }`
+
+   3. **Não Modifique a Intenção**:
+      - Repasse a solicitação do usuário integralmente para o Arquiteto.
+      - Repasse o plano do Arquiteto integralmente para o Builder.
+
+   4. **Tratamento de Erros**:
+      - Se o `architect` falhar ou retornar algo vago, não chame o `builder`. Use `final_answer` explicando o problema ou `ask_user` para pedir detalhes.
+
+  ## Formato de Saída (Strict JSON)
+  Thought: Preciso obter um plano técnico para esta tarefa. 
+  Action: call_flow = {"flowId":"architect","input":{"task":"tarefa do usuário"}}
+
+  Após receber o plano:
+
+  Thought: Plano recebido, vou delegar para execução. 
+  Action: call_flow = {"flowId":"builder","input":{"task":"tarefa do usuário"},"shared":{"plan":"plano recebido do architect"}}
+
+  **Examples of Valid Turns:**
+
+   ### Cenário: Início do Projeto
+   Thought: O usuário quer criar um sistema de login. Primeiro preciso da arquitetura.
+   Action: call_flow = { "flowId": "architect", "input": { "task": "Criar sistema de login com JWT" } }
+
+   ### Cenário: Passando do Arquiteto para o Construtor
+   Observation: [O architect retornou uma especificação técnica detalhada em Markdown]
+   Thought: Recebi a especificação do Arquiteto. Agora vou delegar a implementação para o Builder, passando o plano no contexto compartilhado.
+   Action: call_flow = { "flowId": "builder", "input": { "task": "Implementar conforme especificação" }, "shared": { "plan": "## Especificação Técnica (Conteúdo recebido do architect)..." } }
+
+   ### Cenário: Finalização
+   Observation: [O builder retornou "Sistema implementado e testado com sucesso"]
+   Thought: O Builder concluiu a tarefa. Vou informar o usuário.
+   Action: final_answer = { "answer": "O sistema de login foi planejado e implementado com sucesso. Os arquivos foram criados em src/auth e os testes passaram." }
+---
+
+# Agente Supervisor (Mariana)
+
+As instruções deste agente estão definidas no frontmatter deste arquivo.

package/dist/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+if (process.stdout.isTTY) {
+    process.stdout.setEncoding('utf-8');
+}
+if (process.stderr.isTTY) {
+    process.stderr.setEncoding('utf-8');
+}
+if (!process.env.LANG) {
+    process.env.LANG = 'en_US.UTF-8';
+}
+if (!process.env.LC_ALL) {
+    process.env.LC_ALL = 'en_US.UTF-8';
+}
+const logger_1 = require("./infrastructure/logging/logger");
+logger_1.logger.info('[FrameCodeCLI] Iniciando CLI...');
+const agent_runtime_1 = require("./agent-runtime");
+(0, agent_runtime_1.initializeAgents)().then((count) => {
+    logger_1.logger.info(`[FrameCodeCLI] ${count} agentes carregados`);
+}).catch((error) => {
+    logger_1.logger.error('[FrameCodeCLI] Erro ao carregar agentes:', error);
+});
+const cli_1 = require("./app/cli");
+(0, cli_1.runCli)();

package/dist/infrastructure/compression/CompressionManager.js

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompressionManager = void 0;
+const frame_agent_sdk_1 = require("@ericnunes/frame-agent-sdk");
+const frame_agent_sdk_2 = require("@ericnunes/frame-agent-sdk");
+const LLMCompressionService_1 = require("./LLMCompressionService");
+const logger_1 = require("../logging/logger");
+const config_1 = require("../config");
+class CompressionManager {
+    constructor(config) {
+        this.compressoes = [];
+        this.compressionCount = 0;
+        const defaultConfig = (0, config_1.loadConfigSync)();
+        this.compressionConfig = {
+            enabled: true,
+            threshold: 0.8,
+            maxCount: 5,
+            maxTokens: 300,
+            logging: true,
+            persist: true,
+            ...config
+        };
+        this.maxCompressoes = this.compressionConfig.maxCount;
+        this.persistKey = sanitizePersistKey(this.compressionConfig.persistKey ?? 'default');
+        this.llmService = new LLMCompressionService_1.LLMCompressionService();
+        if (!this.llmService.isConfigured()) {
+            logger_1.logger.warn('[CompressionManager] LLM não configurado corretamente');
+            logger_1.logger.debug('[CompressionManager] Config info:', this.llmService.getConfigInfo());
+        }
+        this.initializeTokenization(defaultConfig.defaults?.maxContextTokens || 240000);
+        if (this.compressionConfig.persist) {
+            this.loadPersistedCompressions();
+        }
+        logger_1.logger.info('[CompressionManager] Inicializado', {
+            enabled: this.compressionConfig.enabled,
+            maxCompressoes: this.maxCompressoes,
+            threshold: this.compressionConfig.threshold,
+            currentCompressions: this.compressoes.length,
+            persistKey: this.persistKey
+        });
+    }
+    initializeTokenization(maxContextTokens) {
+        try {
+            this.tokenizerService = new frame_agent_sdk_1.TokenizerService('gpt-4');
+            this.chatHistoryManager = new frame_agent_sdk_1.ChatHistoryManager({
+                maxContextTokens,
+                tokenizer: this.tokenizerService
+            });
+            logger_1.logger.debug('[CompressionManager] Serviços de tokenização inicializados');
+        }
+        catch (error) {
+            logger_1.logger.error('[CompressionManager] Erro ao inicializar tokenização:', error);
+        }
+    }
+    async handleTokenOverflow(error, state) {
+        if (!this.compressionConfig.enabled) {
+            throw error;
+        }
+        logger_1.logger.error('[CompressionManager] Estouro de tokens detectado, iniciando compressão emergencial');
+        logger_1.logger.debug('[CompressionManager] Erro original:', error.message);
+        try {
+            const messages = this.extractMessagesFromState(state);
+            await this.performEmergencyCompression(messages);
+            const compressedState = await this.buildCompressedState(state);
+            logger_1.logger.info('[CompressionManager] Compressão emergencial concluída, retentando execução');
+            return compressedState;
+        }
+        catch (compressionError) {
+            logger_1.logger.error('[CompressionManager] Falha na compressão emergencial:', compressionError);
+            throw error;
+        }
+    }
+    async checkProactiveCompression(state) {
+        if (!this.compressionConfig.enabled || !this.chatHistoryManager) {
+            return false;
+        }
+        try {
+            const messages = this.extractMessagesFromState(state);
+            const currentTokens = this.tokenizerService.countTokens(messages);
+            const maxTokens = 240000;
+            const usageRatio = currentTokens / maxTokens;
+            const shouldCompress = usageRatio >= this.compressionConfig.threshold;
+            if (this.compressionConfig.logging) {
+                logger_1.logger.debug(`[CompressionManager] Uso de tokens: ${currentTokens}/${maxTokens} (${(usageRatio * 100).toFixed(1)}%)`);
+                if (shouldCompress) {
+                    logger_1.logger.info(`[CompressionManager] Threshold atingido (${(this.compressionConfig.threshold * 100)}%), compressão proativa recomendada`);
+                }
+            }
+            return shouldCompress;
+        }
+        catch (error) {
+            logger_1.logger.error('[CompressionManager] Erro na verificação proativa:', error);
+            return false;
+        }
+    }
+    async performProactiveCompression(state) {
+        logger_1.logger.info('[CompressionManager] Iniciando compressão proativa');
+        try {
+            const messages = this.extractMessagesFromState(state);
+            await this.performEmergencyCompression(messages);
+            return await this.buildCompressedState(state);
+        }
+        catch (error) {
+            logger_1.logger.error('[CompressionManager] Erro na compressão proativa:', error);
+            throw error;
+        }
+    }
+    async performEmergencyCompression(messages) {
+        if (!this.llmService.isConfigured()) {
+            throw new Error('LLM não configurado para compressão');
+        }
+        const protectedMessages = this.extractProtectedMessages(messages);
+        const contextToCompress = this.extractCompressibleContext(messages);
+        if (contextToCompress.trim().length === 0) {
+            logger_1.logger.warn('[CompressionManager] Nenhum contexto para comprimir');
+            return;
+        }
+        try {
+            let newCompression;
+            if (this.compressionCount === 0) {
+                newCompression = await this.llmService.compressInitial(contextToCompress);
+                this.compressionCount = 1;
+                this.compressoes.push(newCompression);
+            }
+            else {
+                newCompression = await this.llmService.compressIncremental(this.compressoes, contextToCompress);
+                if (this.compressoes.length >= this.maxCompressoes) {
+                    await this.mergeOldestCompressions();
+                }
+                this.compressionCount++;
+                this.compressoes.push(newCompression);
+            }
+            if (this.compressionConfig.persist) {
+                this.persistCompressions();
+            }
+            logger_1.logger.info(`[CompressionManager] Compressão #${this.compressionCount} realizada com sucesso`);
+        }
+        catch (error) {
+            logger_1.logger.error('[CompressionManager] Erro durante compressão emergencial:', error);
+            throw error;
+        }
+    }
+    async mergeOldestCompressions() {
+        if (this.compressoes.length < 2) {
+            return;
+        }
+        logger_1.logger.info('[CompressionManager] Mesclando compressões mais antigas');
+        let oldest1;
+        let oldest2;
+        try {
+            oldest1 = this.compressoes.shift();
+            oldest2 = this.compressoes.shift();
+            if (!oldest1 || !oldest2) {
+                throw new Error('Não há compressões suficientes para mesclar');
+            }
+            const merged = await this.llmService.mergeCompressions(oldest1, oldest2);
+            this.compressoes.unshift(merged);
+            logger_1.logger.info('[CompressionManager] Compressões mescladas com sucesso');
+        }
+        catch (error) {
+            logger_1.logger.error('[CompressionManager] Erro ao mesclar compressões:', error);
+            if (oldest1 && oldest2) {
+                this.compressoes.unshift(oldest2, oldest1);
+            }
+            throw error;
+        }
+    }
+    extractProtectedMessages(messages) {
+        const protectedMessages = [];
+        const systemMessage = messages.find(msg => msg.role === 'system');
+        if (systemMessage) {
+            protectedMessages.push(systemMessage);
+        }
+        const userMessages = messages.filter(msg => msg.role === 'user');
+        if (userMessages.length > 0) {
+            protectedMessages.push(userMessages[0]);
+        }
+        if (userMessages.length > 1) {
+            protectedMessages.push(userMessages[userMessages.length - 1]);
+        }
+        return protectedMessages;
+    }
+    extractCompressibleContext(messages) {
+        const protectedIndices = new Set();
+        messages.forEach((msg, index) => {
+            if (msg.role === 'system') {
+                protectedIndices.add(index);
+            }
+            else if (msg.role === 'user') {
+                const userMessages = messages.filter(m => m.role === 'user');
+                if (index === messages.indexOf(userMessages[0]) || index === messages.lastIndexOf(userMessages[userMessages.length - 1])) {
+                    protectedIndices.add(index);
+                }
+            }
+        });
+        const compressibleMessages = messages.filter((_, index) => !protectedIndices.has(index));
+        return compressibleMessages
+            .map(msg => `[${msg.role.toUpperCase()}]: ${(0, frame_agent_sdk_2.extractTextFromMessage)(msg)}`)
+            .join('\n\n');
+    }
+    extractMessagesFromState(state) {
+        return state.messages || [];
+    }
+    async buildCompressedState(originalState) {
+        const originalMessages = this.extractMessagesFromState(originalState);
+        const protectedMessages = this.extractProtectedMessages(originalMessages);
+        const newMessages = [...protectedMessages];
+        if (this.compressoes.length > 0) {
+            const compressionContext = this.getCompressionPrompt();
+            newMessages.unshift({
+                role: 'system',
+                content: compressionContext
+            });
+        }
+        return {
+            ...originalState,
+            messages: newMessages
+        };
+    }
+    getCompressionPrompt() {
+        if (this.compressoes.length === 0) {
+            return '';
+        }
+        return `CONTEXTO ACUMULADO DA SESSÃO:
+${this.compressoes.join('\n')}`;
+    }
+    getCompressionHistory() {
+        return [...this.compressoes];
+    }
+    getCompressionStats() {
+        return {
+            compressionCount: this.compressionCount,
+            currentCompressions: this.compressoes.length,
+            maxCompressions: this.maxCompressoes,
+            enabled: this.compressionConfig.enabled,
+            threshold: this.compressionConfig.threshold,
+            persistKey: this.persistKey,
+            compressionHistory: this.compressoes.map((comp, index) => ({
+                index: index + 1,
+                preview: comp.substring(0, 100) + (comp.length > 100 ? '...' : ''),
+                length: comp.length
+            }))
+        };
+    }
+    clearCompressions() {
+        this.compressoes = [];
+        this.compressionCount = 0;
+        if (this.compressionConfig.persist) {
+            this.clearPersistedCompressions();
+        }
+        logger_1.logger.info('[CompressionManager] Compressões limpas');
+    }
+    persistCompressions() {
+        try {
+            const fs = require('fs');
+            const path = require('path');
+            const persistPath = path.join(process.cwd(), `.frame-code-compressions.${this.persistKey}.json`);
+            const data = {
+                compressoes: this.compressoes,
+                compressionCount: this.compressionCount,
+                persistKey: this.persistKey,
+                timestamp: new Date().toISOString()
+            };
+            fs.writeFileSync(persistPath, JSON.stringify(data, null, 2));
+            logger_1.logger.debug('[CompressionManager] Compressões persistidas');
+        }
+        catch (error) {
+            logger_1.logger.error('[CompressionManager] Erro ao persistir compressões:', error);
+        }
+    }
+    loadPersistedCompressions() {
+        try {
+            const fs = require('fs');
+            const path = require('path');
+            const persistPath = path.join(process.cwd(), `.frame-code-compressions.${this.persistKey}.json`);
+            if (fs.existsSync(persistPath)) {
+                const data = JSON.parse(fs.readFileSync(persistPath, 'utf-8'));
+                this.compressoes = data.compressoes || [];
+                this.compressionCount = data.compressionCount || 0;
+                logger_1.logger.info(`[CompressionManager] Carregadas ${this.compressoes.length} compressões persistidas`);
+            }
+        }
+        catch (error) {
+            logger_1.logger.error('[CompressionManager] Erro ao carregar compressões persistidas:', error);
+        }
+    }
+    clearPersistedCompressions() {
+        try {
+            const fs = require('fs');
+            const path = require('path');
+            const persistPath = path.join(process.cwd(), `.frame-code-compressions.${this.persistKey}.json`);
+            if (fs.existsSync(persistPath)) {
+                fs.unlinkSync(persistPath);
+                logger_1.logger.debug('[CompressionManager] Arquivo de persistência removido');
+            }
+        }
+        catch (error) {
+            logger_1.logger.error('[CompressionManager] Erro ao limpar persistência:', error);
+        }
+    }
+    async forceCompression(state) {
+        logger_1.logger.info('[CompressionManager] Forçando compressão manual');
+        if (!this.compressionConfig.enabled) {
+            throw new Error('Compressão está desabilitada');
+        }
+        return await this.performProactiveCompression(state);
+    }
+}
+exports.CompressionManager = CompressionManager;
+function sanitizePersistKey(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return 'default';
+    return trimmed.replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 80);
+}

package/dist/infrastructure/compression/LLMCompressionService.js

@@ -0,0 +1,211 @@
+"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.LLMCompressionService = void 0;
+const logger_1 = require("../logging/logger");
+const config_1 = require("../config");
+class LLMCompressionService {
+    constructor(llmConfig) {
+        if (llmConfig) {
+            this.llmConfig = llmConfig;
+            this.modelName = llmConfig.model;
+        }
+        else {
+            const config = (0, config_1.loadConfigSync)();
+            this.llmConfig = {
+                model: config.defaults?.model || 'gpt-4o-mini',
+                provider: config.provider,
+                apiKey: config.apiKey,
+                baseUrl: config.baseURL,
+                defaults: {
+                    maxTokens: config.defaults?.maxTokens,
+                    temperature: config.defaults?.temperature,
+                }
+            };
+            this.modelName = this.llmConfig.model;
+        }
+    }
+    async compressInitial(context) {
+        const prompt = this.buildInitialCompressionPrompt(context);
+        logger_1.logger.info('[LLMCompressionService] Iniciando compressão inicial');
+        logger_1.logger.debug(`[LLMCompressionService] Contexto tem ${context.length} caracteres`);
+        try {
+            const result = await this.callLLM(prompt);
+            logger_1.logger.info('[LLMCompressionService] Compressão inicial concluída');
+            return result;
+        }
+        catch (error) {
+            logger_1.logger.error('[LLMCompressionService] Erro na compressão inicial:', error);
+            throw new Error(`Falha na compressão inicial: ${error instanceof Error ? error.message : 'Erro desconhecido'}`);
+        }
+    }
+    async compressIncremental(compressoes, newContext) {
+        const compressionCount = compressoes.length + 1;
+        const prompt = this.buildIncrementalCompressionPrompt(compressoes, newContext, compressionCount);
+        logger_1.logger.info(`[LLMCompressionService] Iniciando compressão incremental #${compressionCount}`);
+        logger_1.logger.debug(`[LLMCompressionService] Baseado em ${compressoes.length} compressões anteriores`);
+        try {
+            const result = await this.callLLM(prompt);
+            logger_1.logger.info(`[LLMCompressionService] Compressão incremental #${compressionCount} concluída`);
+            return result;
+        }
+        catch (error) {
+            logger_1.logger.error(`[LLMCompressionService] Erro na compressão incremental #${compressionCount}:`, error);
+            throw new Error(`Falha na compressão incremental: ${error instanceof Error ? error.message : 'Erro desconhecido'}`);
+        }
+    }
+    async mergeCompressions(comp1, comp2) {
+        const prompt = this.buildMergeCompressionPrompt(comp1, comp2);
+        logger_1.logger.info('[LLMCompressionService] Iniciando mesclagem de compressões');
+        try {
+            const result = await this.callLLM(prompt);
+            logger_1.logger.info('[LLMCompressionService] Mesclagem de compressões concluída');
+            return result;
+        }
+        catch (error) {
+            logger_1.logger.error('[LLMCompressionService] Erro na mesclagem de compressões:', error);
+            throw new Error(`Falha na mesclagem de compressões: ${error instanceof Error ? error.message : 'Erro desconhecido'}`);
+        }
+    }
+    buildInitialCompressionPrompt(context) {
+        return `Você é um especialista em sumarizar conversas de desenvolvimento.
+
+Comprima este contexto completo em uma sumarização concisa:
+${context}
+
+Formato obrigatório: "COMPRESSÃO 1: [sua sumarização]"
+
+Preserve:
+- Objetivos principais do projeto/sessão
+- Contexto técnico essencial
+- Primeiras decisões ou requisitos
+- Arquivos ou tecnologias mencionadas
+
+Priorize:
+- Informações técnicas importantes sobre código, arquivos e decisões
+- Requisitos e objetivos definidos
+- Problemas e soluções identificados
+
+Responda APENAS com a compressão no formato especificado, sem comentários adicionais.`;
+    }
+    buildIncrementalCompressionPrompt(compressoes, newContext, compressionNumber) {
+        const compressoesText = compressoes
+            .map((comp, index) => `COMPRESSÃO ${index + 1}: ${comp}`)
+            .join('\n');
+        return `Você está gerenciando o contexto acumulado de uma longa conversa de desenvolvimento.
+
+Compressões anteriores acumuladas:
+${compressoesText}
+
+Novo contexto recente:
+${newContext}
+
+Crie uma nova compressão que INTEGRE TODAS as informações anteriores com o novo contexto.
+
+Formato obrigatório: "COMPRESSÃO ${compressionNumber}: [nova sumarização integrada]"
+
+Mantenha:
+- Progresso acumulado do projeto
+- Decisões importantes de todas as etapas
+- Problemas resolvidos e pendências
+- Continuidade do contexto técnico
+
+Priorize:
+- Informações técnicas importantes sobre código, arquivos e decisões
+- Requisitos e objetivos definidos
+- Problemas e soluções identificados
+
+Responda APENAS com a compressão no formato especificado, sem comentários adicionais.`;
+    }
+    buildMergeCompressionPrompt(comp1, comp2) {
+        return `Mescla estas duas compressões antigas em uma única sumarização coesa:
+
+COMPRESSÃO A: ${comp1}
+COMPRESSÃO B: ${comp2}
+
+Crie uma nova compressão combinada (máx 400 tokens) que preserve o essencial de ambas.
+Formato: "COMPRESSÃO COMBINADA: [sumarização unificada]"
+
+Responda APENAS com a compressão combinada no formato especificado, sem comentários adicionais.`;
+    }
+    async callLLM(prompt) {
+        const { OpenAI } = await Promise.resolve().then(() => __importStar(require('openai')));
+        const openai = new OpenAI({
+            apiKey: this.llmConfig.apiKey,
+            baseURL: this.llmConfig.baseUrl,
+        });
+        const config = (0, config_1.loadConfigSync)();
+        const maxTokens = config.compression?.maxTokens || 500;
+        try {
+            const response = await openai.chat.completions.create({
+                model: this.modelName,
+                messages: [
+                    {
+                        role: 'user',
+                        content: prompt
+                    }
+                ],
+                max_tokens: maxTokens,
+                temperature: 0.3,
+            });
+            const content = response.choices[0]?.message?.content?.trim();
+            if (!content) {
+                throw new Error('Resposta vazia do LLM');
+            }
+            if (!content.includes('COMPRESSÃO')) {
+                logger_1.logger.warn('[LLMCompressionService] Formato da resposta não parece válido:', content);
+            }
+            return content;
+        }
+        catch (error) {
+            logger_1.logger.error('[LLMCompressionService] Erro na chamada ao LLM:', error);
+            throw error;
+        }
+    }
+    isConfigured() {
+        return !!(this.llmConfig.apiKey && this.llmConfig.model);
+    }
+    getConfigInfo() {
+        return {
+            model: this.modelName,
+            provider: this.llmConfig.provider,
+            hasApiKey: !!this.llmConfig.apiKey,
+            hasBaseUrl: !!this.llmConfig.baseUrl,
+            maxTokens: this.llmConfig.defaults?.maxTokens,
+            temperature: this.llmConfig.defaults?.temperature,
+        };
+    }
+}
+exports.LLMCompressionService = LLMCompressionService;

package/dist/infrastructure/compression/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompressionPromptConfig = exports.createDefaultPromptConfig = exports.CLIPromptBuilder = exports.LLMCompressionService = exports.CompressionManager = void 0;
+var CompressionManager_1 = require("./CompressionManager");
+Object.defineProperty(exports, "CompressionManager", { enumerable: true, get: function () { return CompressionManager_1.CompressionManager; } });
+var LLMCompressionService_1 = require("./LLMCompressionService");
+Object.defineProperty(exports, "LLMCompressionService", { enumerable: true, get: function () { return LLMCompressionService_1.LLMCompressionService; } });
+var promptBuilder_1 = require("./promptBuilder");
+Object.defineProperty(exports, "CLIPromptBuilder", { enumerable: true, get: function () { return promptBuilder_1.CLIPromptBuilder; } });
+Object.defineProperty(exports, "createDefaultPromptConfig", { enumerable: true, get: function () { return promptBuilder_1.createDefaultPromptConfig; } });
+Object.defineProperty(exports, "createCompressionPromptConfig", { enumerable: true, get: function () { return promptBuilder_1.createCompressionPromptConfig; } });