claude-cli-advanced.cjs

#!/usr/bin/env node

const readline = require('readline');
const https = require('https');
const fs = require('fs');
const path = require('path');

// Configuração padrão
let config = {
  apiKey: process.env.ANTHROPIC_API_KEY,
  model: process.env.MODEL || 'claude-3-5-sonnet-20241022',
  maxTokens: parseInt(process.env.MAX_TOKENS) || 4000,
  systemPrompt: 'Você é um assistente de IA útil. Responda sempre em português brasileiro.'
};

// Carregar configuração de arquivo se existir
function loadConfig() {
  const configFiles = ['.env', '.claude-config', 'claude.config.json'];
  
  for (const file of configFiles) {
    if (fs.existsSync(file)) {
      try {
        if (file.endsWith('.json')) {
          const fileConfig = JSON.parse(fs.readFileSync(file, 'utf8'));
          config = { ...config, ...fileConfig };
        } else {
          const content = fs.readFileSync(file, 'utf8');
          const lines = content.split('\n');
          
          for (const line of lines) {
            if (line.includes('=') && !line.startsWith('#')) {
              const [key, value] = line.split('=');
              const cleanKey = key.trim();
              const cleanValue = value.trim().replace(/"/g, '');
              
              switch (cleanKey) {
                case 'ANTHROPIC_API_KEY':
                  config.apiKey = cleanValue;
                  break;
                case 'MODEL':
                  config.model = cleanValue;
                  break;
                case 'MAX_TOKENS':
                  config.maxTokens = parseInt(cleanValue);
                  break;
                case 'SYSTEM_PROMPT':
                  config.systemPrompt = cleanValue;
                  break;
              }
            }
          }
        }
        console.log(`✅ Configuração carregada de: ${file}`);
        break;
      } catch (error) {
        console.warn(`⚠️  Erro ao carregar ${file}:`, error.message);
      }
    }
  }
}

// Verificar configuração
function validateConfig() {
  if (!config.apiKey) {
    console.error('❌ Erro: ANTHROPIC_API_KEY não encontrada');
    console.log('💡 Configure sua chave da API:');
    console.log('   1. Acesse: https://console.anthropic.com/');
    console.log('   2. Crie uma nova chave da API');
    console.log('   3. Configure no ambiente ou arquivo de configuração');
    process.exit(1);
  }
}

// Comandos especiais
const commands = {
  '/help': () => {
    console.log('\n📖 Comandos disponíveis:');
    console.log('   /help     - Mostra esta ajuda');
    console.log('   /clear    - Limpa o histórico da conversa');
    console.log('   /config   - Mostra configuração atual');
    console.log('   /save     - Salva conversa em arquivo');
    console.log('   /load     - Carrega conversa de arquivo');
    console.log('   /model    - Lista modelos disponíveis');
    console.log('   sair      - Encerra o programa');
    console.log('');
  },
  
  '/clear': () => {
    conversation.length = 1; // Mantém apenas o prompt do sistema
    console.log('🧹 Histórico da conversa limpo');
  },
  
  '/config': () => {
    console.log('\n⚙️  Configuração atual:');
    console.log(`   Modelo: ${config.model}`);
    console.log(`   Max Tokens: ${config.maxTokens}`);
    console.log(`   API Key: ${config.apiKey.substring(0, 10)}...`);
    console.log(`   System Prompt: ${config.systemPrompt.substring(0, 50)}...`);
    console.log('');
  },
  
  '/save': () => {
    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
    const filename = `conversa-${timestamp}.json`;
    
    try {
      fs.writeFileSync(filename, JSON.stringify(conversation, null, 2));
      console.log(`💾 Conversa salva em: ${filename}`);
    } catch (error) {
      console.error('❌ Erro ao salvar:', error.message);
    }
  },
  
  '/load': () => {
    console.log('📁 Arquivos de conversa disponíveis:');
    const files = fs.readdirSync('.').filter(f => f.startsWith('conversa-') && f.endsWith('.json'));
    
    if (files.length === 0) {
      console.log('   Nenhum arquivo de conversa encontrado');
      return;
    }
    
    files.forEach((file, index) => {
      console.log(`   ${index + 1}. ${file}`);
    });
    
    rl.question('\nEscolha o número do arquivo (ou Enter para cancelar): ', (answer) => {
      const index = parseInt(answer) - 1;
      if (index >= 0 && index < files.length) {
        try {
          const content = fs.readFileSync(files[index], 'utf8');
          conversation = JSON.parse(content);
          console.log(`✅ Conversa carregada de: ${files[index]}`);
        } catch (error) {
          console.error('❌ Erro ao carregar:', error.message);
        }
      }
    });
  },
  
  '/model': () => {
    console.log('\n🤖 Modelos disponíveis:');
    console.log('   claude-3-5-sonnet-20241022  (padrão, rápido e eficiente)');
    console.log('   claude-3-opus-20240229      (mais poderoso, mais lento)');
    console.log('   claude-3-haiku-20240307     (mais rápido, menos poderoso)');
    console.log('');
  }
};

// Carregar configuração
loadConfig();
validateConfig();

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

function askQuestion(question) {
  return new Promise((resolve) => {
    rl.question(question, resolve);
  });
}

function makeClaudeRequest(messages) {
  return new Promise((resolve, reject) => {
    const data = JSON.stringify({
      model: config.model,
      max_tokens: config.maxTokens,
      messages: messages
    });

    const options = {
      hostname: 'api.anthropic.com',
      port: 443,
      path: '/v1/messages',
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Content-Length': data.length,
        'x-api-key': config.apiKey,
        'anthropic-version': '2023-06-01'
      }
    };

    const req = https.request(options, (res) => {
      let responseData = '';
      
      res.on('data', (chunk) => {
        responseData += chunk;
      });
      
      res.on('end', () => {
        try {
          const response = JSON.parse(responseData);
          if (response.content && response.content[0]) {
            resolve(response.content[0].text);
          } else {
            reject(new Error('Resposta inválida da API'));
          }
        } catch (error) {
          reject(error);
        }
      });
    });

    req.on('error', (error) => {
      reject(error);
    });

    req.write(data);
    req.end();
  });
}

async function main() {
  console.log('🤖 Claude CLI Avançado - Assistente de IA no Terminal');
  console.log('💡 Digite "/help" para ver comandos disponíveis');
  console.log('💡 Digite "sair" para encerrar\n');

  const conversation = [
    {
      role: 'user',
      content: config.systemPrompt
    }
  ];

  while (true) {
    try {
      const userInput = await askQuestion('👤 Você: ');
      
      if (userInput.toLowerCase() === 'sair') {
        console.log('👋 Até logo!');
        break;
      }

      if (!userInput.trim()) continue;

      // Verificar comandos especiais
      if (userInput.startsWith('/')) {
        const command = commands[userInput.toLowerCase()];
        if (command) {
          command();
        } else {
          console.log('❌ Comando não reconhecido. Digite "/help" para ver comandos disponíveis.');
        }
        continue;
      }

      console.log('🤖 Claude está pensando...\n');

      conversation.push({
        role: 'user',
        content: userInput
      });

      const response = await makeClaudeRequest(conversation);
      
      console.log('🤖 Claude:', response);
      console.log('');

      conversation.push({
        role: 'assistant',
        content: response
      });

    } catch (error) {
      console.error('❌ Erro:', error.message);
    }
  }

  rl.close();
}

main().catch(console.error);