bimmo-cli 1.2.0

package/.bimmo-context.md

@@ -0,0 +1,26 @@
+# BIMMO-CLI: Protocolo de Operação e Contexto
+
+Você é o **bimmo**, uma IA universal operando via terminal com uma interface verde e lavanda. Seu objetivo é auxiliar o usuário em tarefas de codificação, pesquisa e automação com máxima precisão.
+
+## 🛡️ Diretrizes de Comportamento
+1. **Identidade:** Você é o bimmo. Mantenha um tom profissional, técnico e direto.
+2. **Modos de Operação:**
+   - **CHAT:** Apenas conversa. Não altere arquivos.
+   - **PLAN:** Analise e descreva mudanças. Não as execute.
+   - **EDIT:** Você tem permissão para usar `write_file` e `run_command`. Aplique as mudanças solicitadas com precisão cirúrgica.
+3. **Padrões de Código:** Siga sempre as convenções existentes no projeto do usuário. Prefira código limpo, tipado (quando aplicável) e bem documentado.
+
+## 🛠️ Ferramentas (Tools)
+Você tem acesso a:
+- `search_internet`: Use para buscar informações atualizadas.
+- `read_file`: Use para ler o contexto de arquivos locais.
+- `write_file`: Use para criar ou modificar arquivos no modo EDIT.
+- `run_command`: Use para executar comandos shell (build, tests, install).
+
+## 📂 Contexto do Projeto
+Sempre que o usuário utilizar `@caminho/do/arquivo`, o conteúdo desse arquivo será anexado à mensagem dele. Use isso para entender a estrutura e a lógica antes de sugerir ou aplicar mudanças.
+
+## ⚠️ Regras Críticas
+- Nunca apague arquivos sem confirmação explícita.
+- No modo EDIT, valide se o código gerado é funcional.
+- Se não tiver certeza de algo, peça clarificação usando o modo CHAT ou PLAN.

package/README.md

@@ -0,0 +1,67 @@
+# 🌿 bimmo-cli
+
+**bimmo** é um assistente de IA universal para o seu terminal, com uma interface elegante em tons de **Verde & Lavanda**. Ele funciona como um agente autônomo e multimodal que gerencia o contexto do seu projeto e executa tarefas complexas.
+
+---
+
+## 📦 Instalação Global
+
+Para ter o **bimmo** sempre disponível no seu terminal como um comando do sistema:
+
+```bash
+npm install -g bimmo-cli
+```
+
+Após a instalação, basta digitar `bimmo` em qualquer pasta:
+
+```bash
+bimmo
+```
+
+---
+
+## ✨ Principais Funcionalidades
+
+### 🤖 Agente Autônomo e Modos de Operação
+- **/chat**: Conversa normal para tirar dúvidas.
+- **/plan**: Analisa o código e descreve o plano de ação sem alterar nada.
+- **/edit**: **Modo Auto-Edit**. A IA tem permissão para ler, criar, editar arquivos e rodar comandos shell para resolver problemas.
+
+### 📁 Contexto Inteligente de Projeto
+- **Auto-Indexação**: O bimmo mapeia a estrutura do seu projeto na inicialização.
+- **Herança de Regras**: Detecta automaticamente arquivos `.bimmorc.json`, `CLAUDE.md` e `INSTRUCTIONS.md`.
+- **Anexos com `@`**: Digite `@caminho/arquivo` para anexar códigos ou imagens à conversa.
+
+### 🌐 Busca e Multi-Provedor
+- **Busca na Web**: Integrado com Tavily API para pesquisas em tempo real.
+- **Perfis**: Salve múltiplos perfis (OpenAI, Anthropic, Gemini, DeepSeek, Grok, Ollama, OpenRouter, Z.ai) e alterne instantaneamente com `/switch`.
+
+---
+
+## 🛠️ Comandos Rápidos no Chat
+
+| Comando | Função |
+| :--- | :--- |
+| `/chat` | Modo conversa. |
+| `/plan` | Modo planejamento (seguro). |
+| `/edit` | Modo edição automática (agente). |
+| `/init` | Cria o arquivo `.bimmorc.json` no projeto. |
+| `/switch [nome]` | Troca de perfil (IA/Chave/Modelo). |
+| `/model [nome]` | Troca apenas o modelo da IA atual. |
+| `/config` | Gerenciar seus perfis e chaves de API. |
+| `@arquivo` | Lê um arquivo ou imagem para o contexto. |
+
+---
+
+## 🚀 Publicando via GitHub (Automação)
+
+Para publicar novas versões no NPM automaticamente usando o GitHub:
+
+1. Suba seu código para um repositório no GitHub.
+2. No NPM, gere um **Access Token (Automation)**.
+3. No GitHub, vá em **Settings > Secrets > Actions** e adicione o secret `NPM_TOKEN`.
+4. Sempre que você criar uma **"New Release"** no GitHub, o projeto será publicado no NPM e ficará disponível para `npm install -g`.
+
+---
+
+Feito com 💜 por Judah.

package/bin/bimmo

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import { startInteractive } from '../src/interface.js';
+import { configure } from '../src/config.js';
+
+program
+  .name('bimmo')
+  .description('bimmo — Sua IA universal no terminal (verde & lavanda)')
+  .version('1.1.0');
+
+program
+  .command('config')
+  .description('Configurar provedor e chave de API')
+  .action(configure);
+
+program.action(startInteractive); // ao digitar só "bimmo" entra no chat
+
+program.parse();

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "bimmo-cli",
+  "version": "1.2.0",
+  "description": "🌿 CLI universal para IAs com interface verde/lavanda, modo agente (Auto-Edit) e contexto inteligente de projeto.",
+  "bin": {
+    "bimmo": "./bin/bimmo"
+  },
+  "type": "module",
+  "keywords": [
+    "ai",
+    "cli",
+    "openai",
+    "anthropic",
+    "gemini",
+    "grok",
+    "deepseek",
+    "openrouter",
+    "agent",
+    "multimodal",
+    "terminal"
+  ],
+  "author": "Judah",
+  "license": "MIT",
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    ".bimmo-context.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.36.3",
+    "@google/generative-ai": "^0.21.0",
+    "@tavily/core": "^0.0.2",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "conf": "^13.0.0",
+    "figlet": "^1.7.0",
+    "inquirer": "^10.1.0",
+    "marked": "^14.0.0",
+    "marked-terminal": "^7.0.0",
+    "mime-types": "^2.1.35",
+    "ollama": "^0.5.12",
+    "openai": "^4.82.0",
+    "ora": "^8.1.1",
+    "zod": "^3.24.1"
+  }
+}

package/src/agent.js

@@ -0,0 +1,110 @@
+import { tavily } from '@tavily/core';
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { getConfig } from './config.js';
+
+const config = getConfig();
+const tvly = config.tavilyKey ? tavily({ apiKey: config.tavilyKey }) : null;
+
+export const tools = [
+  {
+    name: 'search_internet',
+    description: 'Pesquisa informações atualizadas na internet sobre qualquer assunto.',
+    parameters: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'O termo de busca' }
+      },
+      required: ['query']
+    },
+    execute: async ({ query }) => {
+      if (!tvly) return 'Erro: Chave de API da Tavily não configurada. Use /config para configurar.';
+      const searchResponse = await tvly.search(query, {
+        searchDepth: 'advanced',
+        maxResults: 5
+      });
+      return JSON.stringify(searchResponse.results.map(r => ({
+        title: r.title,
+        url: r.url,
+        content: r.content
+      })));
+    }
+  },
+  {
+    name: 'read_file',
+    description: 'Lê o conteúdo de um arquivo no sistema.',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Caminho do arquivo' }
+      },
+      required: ['path']
+    },
+    execute: async ({ path: filePath }) => {
+      try {
+        return fs.readFileSync(filePath, 'utf-8');
+      } catch (err) {
+        return `Erro ao ler arquivo: ${err.message}`;
+      }
+    }
+  },
+  {
+    name: 'write_file',
+    description: 'Cria ou sobrescreve um arquivo com um conteúdo específico.',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Camin de destino' },
+        content: { type: 'string', description: 'Conteúdo do arquivo' }
+      },
+      required: ['path', 'content']
+    },
+    execute: async ({ path: filePath, content }) => {
+      try {
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(filePath, content);
+        return `Arquivo ${filePath} criado com sucesso.`;
+      } catch (err) {
+        return `Erro ao escrever arquivo: ${err.message}`;
+      }
+    }
+  },
+  {
+    name: 'run_command',
+    description: 'Executa um comando shell no sistema.',
+    parameters: {
+      type: 'object',
+      properties: {
+        command: { type: 'string', description: 'Comando shell a ser executado' }
+      },
+      required: ['command']
+    },
+    execute: async ({ command }) => {
+      try {
+        const output = execSync(command, { encoding: 'utf-8', timeout: 30000 });
+        return output || 'Comando executado sem retorno visual.';
+      } catch (err) {
+        return `Erro ao executar comando: ${err.stderr || err.message}`;
+      }
+    }
+  }
+];
+
+export async function handleToolCalls(toolCalls) {
+  const results = [];
+  for (const call of toolCalls) {
+    const tool = tools.find(t => t.name === call.name);
+    if (tool) {
+      console.log(`\n  ${tool.name === 'search_internet' ? '🌐' : '🛠️'}  Executando: ${tool.name}...`);
+      const result = await tool.execute(call.args);
+      results.push({
+        callId: call.id,
+        name: call.name,
+        result
+      });
+    }
+  }
+  return results;
+}

package/src/config.js

@@ -0,0 +1,151 @@
+import Conf from 'conf';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+
+const config = new Conf({ projectName: 'bimmo-cli' });
+
+const providers = {
+  openai: { baseURL: 'https://api.openai.com/v1', defaultModel: 'gpt-4o' },
+  anthropic: { baseURL: 'https://api.anthropic.com/v1', defaultModel: 'claude-3-5-sonnet-20240620' },
+  grok: { baseURL: 'https://api.x.ai/v1', defaultModel: 'grok-2-1212' },
+  gemini: { baseURL: 'https://generativelanguage.googleapis.com/v1beta', defaultModel: 'gemini-2.0-flash' },
+  ollama: { baseURL: 'http://localhost:11434/api', defaultModel: 'llama3.2' },
+  openrouter: { baseURL: 'https://openrouter.ai/api/v1', defaultModel: 'google/gemini-2.0-flash-exp:free' },
+  deepseek: { baseURL: 'https://api.deepseek.com', defaultModel: 'deepseek-chat' },
+  zai: { baseURL: 'https://api.z.ai/v1', defaultModel: 'glm-4' }
+};
+
+export async function configure() {
+  console.log(chalk.cyan('🔧 Configuração do bimmo-cli\n'));
+
+  const profiles = config.get('profiles') || {};
+  const profileList = Object.keys(profiles);
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'O que deseja fazer?',
+      choices: [
+        { name: 'Criar novo perfil de IA', value: 'create' },
+        { name: 'Selecionar perfil ativo', value: 'select' },
+        { name: 'Configurar chave Tavily', value: 'tavily' },
+        { name: 'Sair', value: 'exit' }
+      ]
+    }
+  ]);
+
+  if (action === 'exit') return;
+
+  if (action === 'tavily') {
+    const { tavilyKey } = await inquirer.prompt([{
+      type: 'input',
+      name: 'tavilyKey',
+      message: 'Chave de API Tavily:',
+      default: config.get('tavilyKey')
+    }]);
+    config.set('tavilyKey', tavilyKey);
+    console.log(chalk.green('✓ Chave Tavily salva.'));
+    return;
+  }
+
+  if (action === 'select') {
+    if (profileList.length === 0) {
+      console.log(chalk.yellow('Nenhum perfil encontrado. Crie um primeiro.'));
+      return configure();
+    }
+    const { selected } = await inquirer.prompt([{
+      type: 'list',
+      name: 'selected',
+      message: 'Escolha o perfil para ativar:',
+      choices: profileList
+    }]);
+    const p = profiles[selected];
+    config.set('provider', p.provider);
+    config.set('apiKey', p.apiKey);
+    config.set('model', p.model);
+    config.set('baseURL', p.baseURL);
+    config.set('activeProfile', selected);
+    console.log(chalk.green(`✓ Perfil "${selected}" ativado!`));
+    return;
+  }
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'profileName',
+      message: 'Dê um nome para este perfil (ex: MeuGPT, ClaudeTrabalho):',
+      validate: i => i.length > 0 || 'Nome obrigatório'
+    },
+    {
+      type: 'list',
+      name: 'provider',
+      message: 'Qual provedor?',
+      choices: Object.keys(providers)
+    },
+    {
+      type: 'input',
+      name: 'apiKey',
+      message: 'API Key:',
+      validate: i => i.length > 5 || 'Chave inválida'
+    },
+    {
+      type: 'input',
+      name: 'model',
+      message: 'Modelo padrão (vazio para default):'
+    },
+    {
+      type: 'input',
+      name: 'customBaseURL',
+      message: 'URL customizada (vazio para default):'
+    }
+  ]);
+
+  const newProfile = {
+    provider: answers.provider,
+    apiKey: answers.apiKey,
+    model: answers.model || providers[answers.provider].defaultModel,
+    baseURL: answers.customBaseURL || providers[answers.provider].baseURL
+  };
+
+  profiles[answers.profileName] = newProfile;
+  config.set('profiles', profiles);
+  
+  // Define como ativo imediatamente
+  config.set('provider', newProfile.provider);
+  config.set('apiKey', newProfile.apiKey);
+  config.set('model', newProfile.model);
+  config.set('baseURL', newProfile.baseURL);
+  config.set('activeProfile', answers.profileName);
+
+  console.log(chalk.green(`\n✅ Perfil "${answers.profileName}" criado e ativado!`));
+}
+
+export function getConfig() {
+  return config.store;
+}
+
+export function updateActiveModel(newModel) {
+  config.set('model', newModel);
+  // Também atualiza no perfil se houver um ativo
+  const active = config.get('activeProfile');
+  if (active) {
+    const profiles = config.get('profiles');
+    profiles[active].model = newModel;
+    config.set('profiles', profiles);
+  }
+}
+
+export function switchProfile(name) {
+  const profiles = config.get('profiles') || {};
+  if (profiles[name]) {
+    const p = profiles[name];
+    config.set('provider', p.provider);
+    config.set('apiKey', p.apiKey);
+    config.set('model', p.model);
+    config.set('baseURL', p.baseURL);
+    config.set('activeProfile', name);
+    return true;
+  }
+  return false;
+}

package/src/interface.js

@@ -0,0 +1,271 @@
+import chalk from 'chalk';
+import figlet from 'figlet';
+import inquirer from 'inquirer';
+import { marked } from 'marked';
+import TerminalRenderer from 'marked-terminal';
+import ora from 'ora';
+import fs from 'fs';
+import path from 'path';
+import mime from 'mime-types';
+
+import { getConfig, configure, updateActiveModel, switchProfile } from './config.js';
+import { createProvider } from './providers/factory.js';
+import { getProjectContext } from './project-context.js';
+
+marked.use(new TerminalRenderer({
+  heading: chalk.hex('#c084fc').bold,
+  code: chalk.hex('#00ff9d'),
+}));
+
+const green = chalk.hex('#00ff9d');
+const lavender = chalk.hex('#c084fc');
+const gray = chalk.gray;
+const bold = chalk.bold;
+const yellow = chalk.yellow;
+
+let currentMode = 'chat'; // 'chat', 'plan', 'edit'
+
+async function processInput(input) {
+  const parts = input.split(' ');
+  const processedContent = [];
+  
+  for (const part of parts) {
+    if (part.startsWith('@')) {
+      const filePath = part.slice(1);
+      try {
+        if (fs.existsSync(filePath)) {
+          const stats = fs.statSync(filePath);
+          if (stats.isFile()) {
+            const mimeType = mime.lookup(filePath) || 'application/octet-stream';
+            
+            if (mimeType.startsWith('image/')) {
+              const base64Image = fs.readFileSync(filePath, { encoding: 'base64' });
+              processedContent.push({
+                type: 'image',
+                mimeType,
+                data: base64Image,
+                fileName: path.basename(filePath)
+              });
+            } else {
+              const textContent = fs.readFileSync(filePath, 'utf-8');
+              processedContent.push({
+                type: 'text',
+                text: `\n--- Arquivo: ${path.basename(filePath)} ---\n${textContent}\n--- Fim do arquivo ---\n`
+              });
+            }
+          }
+        } else {
+          processedContent.push({ type: 'text', text: part });
+        }
+      } catch (err) {
+        processedContent.push({ type: 'text', text: part });
+      }
+    } else {
+      processedContent.push({ type: 'text', text: part });
+    }
+  }
+
+  const hasImage = processedContent.some(c => c.type === 'image');
+  
+  if (!hasImage) {
+    return processedContent.map(c => c.text).join(' ');
+  }
+
+  const finalContent = [];
+  let currentText = "";
+
+  for (const item of processedContent) {
+    if (item.type === 'text') {
+      currentText += (currentText ? " " : "") + item.text;
+    } else {
+      if (currentText) {
+        finalContent.push({ type: 'text', text: currentText });
+        currentText = "";
+      }
+      finalContent.push(item);
+    }
+  }
+  if (currentText) finalContent.push({ type: 'text', text: currentText });
+
+  return finalContent;
+}
+
+function getModeStyle() {
+  switch (currentMode) {
+    case 'plan': return yellow.bold(' [PLAN] ');
+    case 'edit': return chalk.red.bold(' [EDIT] ');
+    default: return lavender.bold(' [CHAT] ');
+  }
+}
+
+export async function startInteractive() {
+  let config = getConfig();
+
+  if (!config.provider || !config.apiKey) {
+    console.log(lavender(figlet.textSync('bimmo', { font: 'slant' })));
+    console.log(gray('\nBem-vindo! Vamos configurar seus perfis de IA.\n'));
+    await configure(); 
+    return startInteractive();
+  }
+
+  let provider = createProvider(config);
+  const messages = [];
+
+  // 1. Injeta o sistema de contexto inteligente do projeto
+  const projectContext = getProjectContext();
+  messages.push({ 
+    role: 'system', 
+    content: projectContext 
+  });
+
+  console.clear();
+  console.log(lavender(figlet.textSync('bimmo', { font: 'small' })));
+  console.log(lavender('─'.repeat(60)));
+  console.log(green(`   Perfil Ativo: ${bold(config.activeProfile || 'Padrão')} (${config.provider.toUpperCase()})`));
+  console.log(green(`   Modelo: ${bold(config.model)}`));
+  console.log(gray('   /chat | /plan | /edit | /switch [perfil] | /model [novo] | /help'));
+  console.log(lavender('─'.repeat(60)) + '\n');
+
+  console.log(lavender('👋 Olá! Sou seu agente BIMMO. No que posso atuar?\n'));
+
+  while (true) {
+    const modeIndicator = getModeStyle();
+    const { input } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'input',
+        message: modeIndicator + green('Você'),
+        prefix: '→',
+      }
+    ]);
+
+    const rawInput = input.trim();
+    const cmd = rawInput.toLowerCase();
+
+    if (cmd === '/exit' || cmd === 'exit' || cmd === 'sair') {
+      console.log(lavender('\n👋 BIMMO encerrando sessão. Até logo!\n'));
+      break;
+    }
+
+    if (cmd === '/chat') { currentMode = 'chat'; console.log(lavender('✓ Modo CHAT.\n')); continue; }
+    if (cmd === '/plan') { currentMode = 'plan'; console.log(yellow('✓ Modo PLAN.\n')); continue; }
+    if (cmd === '/edit') { currentMode = 'edit'; console.log(chalk.red('⚠️  Modo EDIT.\n')); continue; }
+
+    // /switch [perfil] -> Troca Perfil + Chave + Provedor + Modelo instantaneamente
+    if (cmd.startsWith('/switch ')) {
+      const profileName = rawInput.split(' ')[1];
+      if (profileName && switchProfile(profileName)) {
+        config = getConfig(); // Atualiza config local
+        provider = createProvider(config); // Recria provedor com nova chave/url
+        console.log(green(`\n✓ Trocado para o perfil "${bold(profileName)}"!`));
+        console.log(gray(`   IA: ${config.provider.toUpperCase()} | Modelo: ${config.model}\n`));
+      } else {
+        console.log(chalk.red(`\n✖ Perfil "${profileName}" não encontrado.\n`));
+      }
+      continue;
+    }
+
+    // /model [modelo] -> Troca apenas o modelo do Perfil atual
+    if (cmd.startsWith('/model ')) {
+      const newModel = rawInput.split(' ')[1];
+      if (newModel) {
+        updateActiveModel(newModel);
+        config.model = newModel;
+        provider = createProvider(config);
+        console.log(green(`\n✓ Modelo atualizado para: ${bold(newModel)}\n`));
+      }
+      continue;
+    }
+
+    if (cmd === '/clear') {
+      messages.length = 0;
+      messages.push({ role: 'system', content: getProjectContext() });
+      console.clear();
+      console.log(lavender('✓ Histórico limpo, contexto preservado.\n'));
+      continue;
+    }
+
+    if (cmd === '/help') {
+      console.log(gray(`
+Comandos Disponíveis:
+  /chat /plan /edit → Mudar modo de operação
+  /switch [nome]   → Mudar PERFIL (Troca Chave/API/IA completa)
+  /model [nome]    → Mudar apenas o MODELO da IA atual
+  /init            → Inicializar .bimmorc.json neste projeto
+  /config          → Gerenciar perfis e chaves
+  /clear           → Resetar conversa (mantém contexto base)
+  @caminho         → Anexar arquivos ou imagens
+      `));
+      continue;
+    }
+
+    if (cmd === '/init') {
+      const bimmoRcPath = path.join(process.cwd(), '.bimmorc.json');
+      if (fs.existsSync(bimmoRcPath)) {
+        const { overwrite } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'overwrite',
+          message: 'O arquivo .bimmorc.json já existe. Deseja sobrescrever?',
+          default: false
+        }]);
+        if (!overwrite) continue;
+      }
+
+      const initialConfig = {
+        projectName: path.basename(process.cwd()),
+        rules: [
+          "Siga as convenções de código existentes.",
+          "Prefira código limpo e modular.",
+          "Sempre valide mudanças antes de aplicar no modo EDIT."
+        ],
+        preferredTech: [],
+        architecture: "Não especificada",
+        ignorePatterns: ["node_modules", "dist", ".git"]
+      };
+
+      fs.writeFileSync(bimmoRcPath, JSON.stringify(initialConfig, null, 2));
+      console.log(green(`\n✅ Arquivo .bimmorc.json criado com sucesso em: ${bold(bimmoRcPath)}\n`));
+      
+      // Recarrega o contexto para a conversa atual
+      messages.push({ 
+        role: 'system', 
+        content: `Novo contexto inicializado via /init:\n${JSON.stringify(initialConfig, null, 2)}` 
+      });
+      continue;
+    }
+
+    if (cmd === '/config') { await configure(); config = getConfig(); provider = createProvider(config); continue; }
+
+    if (rawInput === '') continue;
+
+    // Injeção dinâmica de instruções de modo
+    let modeInstr = "";
+    if (currentMode === 'plan') modeInstr = "\n[MODO PLAN] Descreva e analise, mas NÃO altere arquivos.";
+    else if (currentMode === 'edit') modeInstr = "\n[MODO EDIT] Você tem permissão para usar write_file e run_command AGORA.";
+
+    const content = await processInput(rawInput);
+    messages.push({ 
+      role: 'user', 
+      content: typeof content === 'string' ? content + modeInstr : [...content, { type: 'text', text: modeInstr }]
+    });
+
+    const spinner = ora({
+      text: lavender(`bimmo (${currentMode}) pensando...`),
+      color: currentMode === 'edit' ? 'red' : 'magenta'
+    }).start();
+
+    try {
+      const responseText = await provider.sendMessage(messages);
+      spinner.stop();
+      messages.push({ role: 'assistant', content: responseText });
+
+      console.log('\n' + lavender('bimmo') + getModeStyle());
+      console.log(lavender('─'.repeat(50)));
+      console.log(marked(responseText));
+      console.log(gray('─'.repeat(50)) + '\n');
+    } catch (err) {
+      spinner.stop();
+      console.error(chalk.red('✖ Erro Crítico:') + ' ' + err.message + '\n');
+    }
+  }
+}

package/src/project-context.js

@@ -0,0 +1,40 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+
+/**
+ * Coleta o contexto completo do projeto para a IA.
+ * Inclui estrutura de arquivos, arquivos de instrução e configurações do .bimmorc
+ */
+export function getProjectContext() {
+  const cwd = process.cwd();
+  let context = "=== CONTEXTO DO PROJETO ===\n";
+
+  // 1. Tentar ler .bimmorc.json para regras customizadas
+  const bimmoRcPath = path.join(cwd, '.bimmorc.json');
+  if (fs.existsSync(bimmoRcPath)) {
+    try {
+      const rc = JSON.parse(fs.readFileSync(bimmoRcPath, 'utf-8'));
+      context += `Regras de Projeto (.bimmorc):\n${JSON.stringify(rc, null, 2)}\n\n`;
+    } catch (e) {}
+  }
+
+  // 2. Tentar ler arquivos de instruções comuns (Claude, Gemini, etc)
+  const instructionFiles = ['CLAUDE.md', 'INSTRUCTIONS.md', '.bimmo-context.md', 'CONTRIBUTING.md'];
+  for (const file of instructionFiles) {
+    const p = path.join(cwd, file);
+    if (fs.existsSync(p)) {
+      context += `Instruções de ${file}:\n${fs.readFileSync(p, 'utf-8')}\n\n`;
+    }
+  }
+
+  // 3. Adicionar estrutura de diretórios (Quantizada/Resumida)
+  try {
+    const tree = execSync('find . -maxdepth 2 -not -path "*/.*" -not -path "./node_modules*"', { encoding: 'utf-8' });
+    context += `Estrutura de Arquivos (Resumo):\n${tree}\n`;
+  } catch (e) {
+    context += "Estrutura de arquivos indisponível.\n";
+  }
+
+  return context;
+}

package/src/providers/anthropic.js

@@ -0,0 +1,77 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { BaseProvider } from './base.js';
+import { tools } from '../agent.js';
+
+export class AnthropicProvider extends BaseProvider {
+  constructor(config) {
+    super(config);
+    this.client = new Anthropic({
+      apiKey: this.config.apiKey
+    });
+  }
+
+  formatContent(content) {
+    if (typeof content === 'string') return content;
+    return content.map(part => {
+      if (part.type === 'text') return { type: 'text', text: part.text };
+      if (part.type === 'image') return {
+        type: 'image',
+        source: { type: 'base64', media_type: part.mimeType, data: part.data }
+      };
+    });
+  }
+
+  async sendMessage(messages) {
+    const systemMessage = messages.find(m => m.role === 'system');
+    const userMessages = messages
+      .filter(m => m.role !== 'system')
+      .map(m => ({
+        role: m.role,
+        content: this.formatContent(m.content)
+      }));
+
+    // Converte tools do agent.js para o formato da Anthropic
+    const anthropicTools = tools.map(t => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.parameters
+    }));
+
+    const response = await this.client.messages.create({
+      model: this.config.model,
+      max_tokens: 4096,
+      system: systemMessage ? systemMessage.content : undefined,
+      messages: userMessages,
+      tools: anthropicTools,
+      temperature: 0.7
+    });
+
+    if (response.stop_reason === 'tool_use') {
+      const toolUse = response.content.find(p => p.type === 'tool_use');
+      const tool = tools.find(t => t.name === toolUse.name);
+      
+      if (tool) {
+        console.log(`\n  ${tool.name === 'search_internet' ? '🌐' : '🛠️'}  Executando: ${tool.name}...`);
+        const result = await tool.execute(toolUse.input);
+        
+        // Adiciona a resposta da IA e o resultado da tool ao histórico
+        const nextMessages = [
+          ...messages,
+          { role: 'assistant', content: response.content },
+          {
+            role: 'user',
+            content: [{
+              type: 'tool_result',
+              tool_use_id: toolUse.id,
+              content: String(result)
+            }]
+          }
+        ];
+        
+        return this.sendMessage(nextMessages);
+      }
+    }
+
+    return response.content[0].text;
+  }
+}

package/src/providers/base.js

@@ -0,0 +1,9 @@
+export class BaseProvider {
+  constructor(config) {
+    this.config = config;
+  }
+
+  async sendMessage(messages) {
+    throw new Error('Método sendMessage deve ser implementado');
+  }
+}

package/src/providers/factory.js

@@ -0,0 +1,20 @@
+import { OpenAIProvider } from './openai.js';
+import { AnthropicProvider } from './anthropic.js';
+import { GrokProvider } from './grok.js';
+import { GeminiProvider } from './gemini.js';
+import { OllamaProvider } from './ollama.js';
+
+export function createProvider(config) {
+  switch (config.provider) {
+    case 'openai': return new OpenAIProvider(config);
+    case 'anthropic': return new AnthropicProvider(config);
+    case 'grok': return new GrokProvider(config);
+    case 'gemini': return new GeminiProvider(config);
+    case 'ollama': return new OllamaProvider(config);
+    case 'openrouter': return new OpenAIProvider(config);
+    case 'deepseek': return new OpenAIProvider(config);
+    case 'zai': return new OpenAIProvider(config);
+    default:
+      throw new Error(`Provider ${config.provider} não suportado ainda.`);
+  }
+}

package/src/providers/gemini.js

@@ -0,0 +1,77 @@
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import { BaseProvider } from './base.js';
+import { tools } from '../agent.js';
+
+export class GeminiProvider extends BaseProvider {
+  constructor(config) {
+    super(config);
+    this.genAI = new GoogleGenerativeAI(this.config.apiKey);
+  }
+
+  formatContent(content) {
+    if (typeof content === 'string') return [{ text: content }];
+    return content.map(part => {
+      if (part.type === 'text') return { text: part.text };
+      if (part.type === 'image') return {
+        inlineData: { mimeType: part.mimeType, data: part.data }
+      };
+    });
+  }
+
+  async sendMessage(messages) {
+    const systemPrompt = messages.find(m => m.role === 'system')?.content;
+    const history = messages
+      .filter(m => m.role !== 'system')
+      .slice(0, -1)
+      .map(msg => ({
+        role: msg.role === 'user' ? 'user' : 'model',
+        parts: this.formatContent(msg.content)
+      }));
+
+    const lastMessageContent = this.formatContent(messages[messages.length - 1].content);
+
+    // Converte tools do agent.js para o formato do Gemini
+    const geminiTools = tools.map(t => ({
+      functionDeclarations: [{
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters
+      }]
+    }));
+
+    const model = this.genAI.getGenerativeModel({ 
+      model: this.config.model,
+      systemInstruction: systemPrompt,
+      tools: geminiTools
+    });
+
+    const chat = model.startChat({
+      history: history,
+      generationConfig: { temperature: 0.7, maxOutputTokens: 8192 },
+    });
+
+    const result = await chat.sendMessage(lastMessageContent);
+    const response = await result.response;
+    
+    // Processamento de Tool Calls no Gemini
+    const call = response.candidates[0].content.parts.find(p => p.functionCall);
+    if (call) {
+      const tool = tools.find(t => t.name === call.functionCall.name);
+      if (tool) {
+        console.log(`\n  ${tool.name === 'search_internet' ? '🌐' : '🛠️'}  Executando: ${tool.name}...`);
+        const result = await tool.execute(call.functionCall.args);
+        
+        // No Gemini, enviamos o resultado de volta para o chat
+        const resultResponse = await chat.sendMessage([{
+          functionResponse: {
+            name: call.functionCall.name,
+            response: { content: result }
+          }
+        }]);
+        return resultResponse.response.text();
+      }
+    }
+
+    return response.text();
+  }
+}

package/src/providers/grok.js

@@ -0,0 +1,47 @@
+import OpenAI from 'openai';
+import { BaseProvider } from './base.js';
+
+export class GrokProvider extends BaseProvider {
+  constructor(config) {
+    super(config);
+    this.client = new OpenAI({
+      apiKey: this.config.apiKey,
+      baseURL: this.config.baseURL || 'https://api.x.ai/v1'
+    });
+  }
+
+  formatMessages(messages) {
+    return messages.map(msg => {
+      if (typeof msg.content === 'string') {
+        return msg;
+      }
+      
+      const content = msg.content.map(part => {
+        if (part.type === 'text') {
+          return { type: 'text', text: part.text };
+        } else if (part.type === 'image') {
+          return {
+            type: 'image_url',
+            image_url: {
+              url: `data:${part.mimeType};base64,${part.data}`
+            }
+          };
+        }
+      });
+
+      return { ...msg, content };
+    });
+  }
+
+  async sendMessage(messages) {
+    const formattedMessages = this.formatMessages(messages);
+    
+    const response = await this.client.chat.completions.create({
+      model: this.config.model,
+      messages: formattedMessages,
+      temperature: 0.7
+    });
+
+    return response.choices[0].message.content;
+  }
+}

package/src/providers/ollama.js

@@ -0,0 +1,51 @@
+import ollama from 'ollama';
+import { BaseProvider } from './base.js';
+
+export class OllamaProvider extends BaseProvider {
+  constructor(config) {
+    super(config);
+    this.client = ollama;
+  }
+
+  formatMessages(messages) {
+    return messages.map(msg => {
+      if (typeof msg.content === 'string') return msg;
+
+      const images = msg.content
+        .filter(part => part.type === 'image')
+        .map(part => part.data); // Ollama espera apenas a string base64
+
+      const text = msg.content
+        .filter(part => part.type === 'text')
+        .map(part => part.text)
+        .join(' ');
+
+      return {
+        role: msg.role,
+        content: text,
+        images: images.length > 0 ? images : undefined
+      };
+    });
+  }
+
+  async sendMessage(messages) {
+    const formattedMessages = this.formatMessages(messages);
+
+    const response = await this.client.chat({
+      model: this.config.model,
+      messages: formattedMessages,
+      stream: false,
+      options: {
+        temperature: 0.7,
+      }
+    });
+
+    const text = response.message?.content;
+
+    if (!text) {
+      throw new Error('Resposta inválida do Ollama');
+    }
+
+    return text;
+  }
+}

package/src/providers/openai.js

@@ -0,0 +1,77 @@
+import OpenAI from 'openai';
+import { BaseProvider } from './base.js';
+import { tools } from '../agent.js';
+
+export class OpenAIProvider extends BaseProvider {
+  constructor(config) {
+    super(config);
+    this.client = new OpenAI({
+      apiKey: this.config.apiKey,
+      baseURL: this.config.baseURL
+    });
+  }
+
+  formatMessages(messages) {
+    return messages.map(msg => {
+      if (typeof msg.content === 'string') return msg;
+      
+      const content = msg.content.map(part => {
+        if (part.type === 'text') return { type: 'text', text: part.text };
+        if (part.type === 'image') return {
+          type: 'image_url',
+          image_url: { url: `data:${part.mimeType};base64,${part.data}` }
+        };
+      });
+      return { ...msg, content };
+    });
+  }
+
+  async sendMessage(messages) {
+    const formattedMessages = this.formatMessages(messages);
+    
+    // Converte tools do agent.js para o formato da OpenAI
+    const openAiTools = tools.map(t => ({
+      type: 'function',
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters
+      }
+    }));
+
+    const response = await this.client.chat.completions.create({
+      model: this.config.model,
+      messages: formattedMessages,
+      tools: openAiTools,
+      tool_choice: 'auto'
+    });
+
+    const message = response.choices[0].message;
+
+    if (message.tool_calls) {
+      const toolResults = [];
+      for (const toolCall of message.tool_calls) {
+        const tool = tools.find(t => t.name === toolCall.function.name);
+        if (tool) {
+          console.log(`\n  ${tool.name === 'search_internet' ? '🌐' : '🛠️'}  Executando: ${tool.name}...`);
+          const args = JSON.parse(toolCall.function.arguments);
+          const result = await tool.execute(args);
+          
+          toolResults.push({
+            role: 'tool',
+            tool_call_id: toolCall.id,
+            content: String(result)
+          });
+        }
+      }
+
+      // Adiciona a chamada da tool e o resultado ao histórico
+      const nextMessages = [...formattedMessages, message, ...toolResults];
+      
+      // Chamada recursiva para processar a resposta final da IA com o resultado da tool
+      return this.sendMessage(nextMessages);
+    }
+
+    return message.content;
+  }
+}