@neetru/cli 2.33.0 → 2.34.0

package/dist/lib/ai/auth-discovery.js

@@ -1,33 +1,33 @@
 /**
- * Auth auto-discovery — detecta Claude Code, Codex (OpenAI) e Gemini CLIs
- * já instalados na máquina e tenta extrair credenciais existentes.
+ * Auth auto-discovery — procura chave já existente na máquina para cada
+ * provedor da lista única (`provedores.ts`), sem mexer em nada (read-only).
  *
- * Motivação: usuário não deveria precisar setar `anthropicApiKey` na mão se
- * ele já tem `claude` (Claude Code) ou `codex` (OpenAI Codex CLI) ou `gemini`
- * (Google Gemini CLI) instalados e logados. CLI Neetru reaproveita as creds
- * pra ligar o `neetru ai` direto.
+ * - Groq e NVIDIA NIM: só chave de API, lida do ambiente (GROQ_API_KEY,
+ *   NVIDIA_API_KEY). Não há programa para instalar.
+ * - OpenAI: a variável OPENAI_API_KEY ou o arquivo do Codex (`codex`, o
+ *   programa de linha de comando da OpenAI) em ~/.codex/auth.json.
  *
- * Estratégia (cross-platform Windows/macOS/Linux):
- *   1. Detectar binário no PATH (`where` no Windows, `command -v` no POSIX).
- *   2. Olhar locais conhecidos de config (~/.claude, ~/.codex, ~/.config/gemini).
- *   3. Olhar env vars (ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY).
- *   4. Reporta o que está disponível sem mexer em nada (read-only).
+ * bug_19d312f3: a descoberta lia também ANTHROPIC_API_KEY, GEMINI_API_KEY,
+ * GOOGLE_API_KEY e os arquivos do Claude Code e do Gemini, e o `neetru ai` saía
+ * usando essas chaves sem o dev escolher. Anthropic e Gemini estão vetados pela
+ * casa e saíram da lista; a descoberta não procura mais as chaves deles.
  *
- * O `setup wizard` (em commands/auth.ts) usa essa detecção pra ofertar
- * install + login per-provider.
+ * O assistente do `neetru auth setup` (commands/auth.ts) usa esta detecção
+ * para mostrar o estado de cada provedor e pedir a chave que falta.
  */
 import { execSync, execFileSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { homedir, platform } from 'node:os';
 import { join } from 'node:path';
+import { CHAVE_DO_PROVEDOR, PROVEDORES_IA, VARIAVEL_DO_PROVEDOR, } from './provedores.js';
 const IS_WINDOWS = platform() === 'win32';
 /**
  * Checa se um binário existe no PATH. Cross-platform via `where` (Windows)
  * e `command -v` (POSIX). Silencioso — captura erro e retorna false.
  */
 function binaryExists(name) {
-    // Defesa em profundidade: hoje `name` vem de uma lista interna fixa
-    // (claude/codex/gemini), mas validamos o formato e evitamos o shell para que
+    // Defesa em profundidade: hoje `name` vem de uma constante interna
+    // (`codex`), mas validamos o formato e evitamos o shell para que
     // isto NUNCA permita injeção de comando, mesmo se a fonte do nome mudar.
     if (!/^[A-Za-z0-9._-]+$/.test(name))
         return false;
@@ -64,60 +64,6 @@ function readJsonSafe(path) {
         return null;
     }
 }
-/**
- * Anthropic / Claude Code.
- * - Binário: `claude` (instalado via npm i -g @anthropic-ai/claude-code)
- * - Config: ~/.claude/.credentials.json (oauth token OU api key)
- * - Env: ANTHROPIC_API_KEY
- */
-function detectAnthropic() {
-    const home = homedir();
-    const installed = binaryExists('claude');
-    // Prioridade 1: env var (mais simples — Anthropic SDK aceita direto)
-    const envKey = process.env.ANTHROPIC_API_KEY;
-    if (envKey && envKey.startsWith('sk-ant-')) {
-        return {
-            provider: 'anthropic',
-            binary: 'claude',
-            npmPackage: '@anthropic-ai/claude-code',
-            installed,
-            credentialSource: 'env',
-            apiKey: envKey,
-            hint: 'usando ANTHROPIC_API_KEY do ambiente',
-        };
-    }
-    // Prioridade 2: arquivo de credentials do Claude Code
-    const credsPath = join(home, '.claude', '.credentials.json');
-    const creds = readJsonSafe(credsPath);
-    if (creds) {
-        // Claude Code armazena `apiKey` ou tokens OAuth. Só populamos apiKey se for sk-ant.
-        const maybeKey = typeof creds.apiKey === 'string' && creds.apiKey.startsWith('sk-ant-')
-            ? creds.apiKey
-            : undefined;
-        return {
-            provider: 'anthropic',
-            binary: 'claude',
-            npmPackage: '@anthropic-ai/claude-code',
-            installed,
-            credentialSource: 'binary-config',
-            credentialPath: credsPath,
-            apiKey: maybeKey,
-            hint: maybeKey
-                ? `extraindo apiKey de ${credsPath}`
-                : `Claude Code logado via OAuth (sem apiKey plaintext) — rode "claude /login" e setting ANTHROPIC_API_KEY ou use "neetru config set anthropicApiKey"`,
-        };
-    }
-    return {
-        provider: 'anthropic',
-        binary: 'claude',
-        npmPackage: '@anthropic-ai/claude-code',
-        installed,
-        credentialSource: null,
-        hint: installed
-            ? 'Claude Code instalado mas sem credenciais — rode "claude" pra logar'
-            : 'instalar: npm i -g @anthropic-ai/claude-code',
-    };
-}
 /**
  * OpenAI / Codex CLI.
  * - Binário: `codex` (npm i -g @openai/codex)
@@ -172,96 +118,48 @@ function detectOpenAI() {
     };
 }
 /**
- * Google / Gemini CLI.
- * - Binário: `gemini` (npm i -g @google/gemini-cli)
- * - Config: ~/.config/gemini/auth.json (Linux/macOS) ou %APPDATA%\gemini\auth.json (Windows)
- * - Env: GEMINI_API_KEY ou GOOGLE_API_KEY
+ * Groq e NVIDIA NIM — provedores OpenAI-compatible, só de chave de API. A
+ * descoberta lê só a variável de ambiente (GROQ_API_KEY / NVIDIA_API_KEY). O
+ * valor PODE ser um pool separado por vírgula; aqui vai cru e o orchestrator
+ * separa.
  */
-function detectGemini() {
-    const home = homedir();
-    const installed = binaryExists('gemini');
-    const envKey = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
-    if (envKey) {
+function detectApenasChave(provider) {
+    const variavel = VARIAVEL_DO_PROVEDOR[provider];
+    const valor = process.env[variavel];
+    if (valor) {
         return {
-            provider: 'gemini',
-            binary: 'gemini',
-            npmPackage: '@google/gemini-cli',
-            installed,
+            provider,
+            installed: false,
             credentialSource: 'env',
-            apiKey: envKey,
-            hint: 'usando GEMINI_API_KEY (ou GOOGLE_API_KEY) do ambiente',
-        };
-    }
-    const candidates = IS_WINDOWS
-        ? [
-            join(process.env.APPDATA ?? join(home, 'AppData', 'Roaming'), 'gemini', 'auth.json'),
-            join(home, '.config', 'gemini', 'auth.json'),
-        ]
-        : [join(home, '.config', 'gemini', 'auth.json')];
-    for (const path of candidates) {
-        const auth = readJsonSafe(path);
-        if (!auth)
-            continue;
-        const maybeKey = typeof auth.apiKey === 'string'
-            ? auth.apiKey
-            : typeof auth.GEMINI_API_KEY === 'string'
-                ? auth.GEMINI_API_KEY
-                : undefined;
-        return {
-            provider: 'gemini',
-            binary: 'gemini',
-            npmPackage: '@google/gemini-cli',
-            installed,
-            credentialSource: 'binary-config',
-            credentialPath: path,
-            apiKey: maybeKey,
-            hint: maybeKey
-                ? `extraindo apiKey de ${path}`
-                : `Gemini logado mas sem apiKey plaintext — rode "gemini auth" com --api-key ou exporte GEMINI_API_KEY`,
+            apiKey: valor,
+            hint: `usando ${variavel} do ambiente`,
         };
     }
     return {
-        provider: 'gemini',
-        binary: 'gemini',
-        npmPackage: '@google/gemini-cli',
-        installed,
+        provider,
+        installed: false,
         credentialSource: null,
-        hint: installed
-            ? 'Gemini instalado mas sem credenciais — rode "gemini auth"'
-            : 'instalar: npm i -g @google/gemini-cli',
+        hint: `sem chave — exporte ${variavel} ou rode "neetru config set ${CHAVE_DO_PROVEDOR[provider]} <chave>"`,
     };
 }
 /**
- * Detecta todos os providers conhecidos. Read-only — não escreve nada,
- * não chama API. Seguro pra rodar em startup do `neetru ai`.
- *
- * Cobre só os providers que têm CLI concorrente (claude/codex/gemini) — o
- * wizard de setup usa esta lista pra ofertar install/login per-binário.
- * Groq e NVIDIA NIM são API-key-only (sem CLI pra instalar); a descoberta
- * deles vive em `discoveredKeys` (env direto).
+ * Um detector por provedor da lista única. O `Record<ProvedorIa, …>` faz o tsc
+ * recusar provedor novo em `PROVEDORES_IA` sem detector aqui.
  */
-export function detectAllProviders() {
-    return [detectAnthropic(), detectOpenAI(), detectGemini()];
-}
+const DETECTORES = {
+    groq: () => detectApenasChave('groq'),
+    nvidia: () => detectApenasChave('nvidia'),
+    openai: detectOpenAI,
+};
 /**
- * Groq + NVIDIA NIM — providers OpenAI-compatible, API-key-only. Descoberta
- * só por env var (GROQ_API_KEY / NVIDIA_API_KEY). O env PODE conter um pool
- * comma-separated; aqui devolvemos o valor cru e o orchestrator parseia.
- * Não disrupta o wizard de binários (detectAllProviders).
+ * Estado de cada provedor da lista única, na ordem dela. Read-only — não
+ * escreve nada, não chama API. Seguro pra rodar em startup do `neetru ai`.
  */
-function discoverApiOnlyKeys() {
-    const out = {};
-    const groq = process.env.GROQ_API_KEY;
-    const nvidia = process.env.NVIDIA_API_KEY;
-    if (groq)
-        out.groq = groq;
-    if (nvidia)
-        out.nvidia = nvidia;
-    return out;
+export function detectAllProviders() {
+    return PROVEDORES_IA.map((p) => DETECTORES[p]());
 }
 /**
- * Conveniência: retorna apenas providers com apiKey extraída (pronta pra usar).
- * Inclui os CLI-discoverable (claude/codex/gemini) + os API-key-only (groq/nvidia).
+ * Conveniência: retorna apenas os provedores com chave achada (pronta pra usar).
  */
 export function discoveredKeys() {
     const out = {};
@@ -269,7 +167,7 @@ export function discoveredKeys() {
         if (p.apiKey)
             out[p.provider] = p.apiKey;
     }
-    return { ...out, ...discoverApiOnlyKeys() };
+    return out;
 }
 /**
  * Tenta instalar globalmente um pacote via npm. Bloqueante, com output

package/dist/lib/ai/orchestrator.d.ts

@@ -1,6 +1,7 @@
-export type ModelId = 'claude' | 'openai' | 'gemini' | 'groq' | 'nvidia' | 'gateway' | 'auto';
+import { type ModeloDoAi, type ProvedorIa } from './provedores.js';
+export type ModelId = ModeloDoAi;
 /** Modelo concreto já resolvido (sem 'auto'). */
-export type ResolvedModel = 'claude' | 'openai' | 'gemini' | 'groq' | 'nvidia' | 'gateway';
+export type ResolvedModel = ProvedorIa | 'gateway';
 export interface Message {
     role: 'user' | 'assistant';
     content: string;
@@ -32,10 +33,16 @@ export declare function parseKeyPool(raw: string | undefined | null): string[];
  *
  * Heurísticas (em ordem):
  *   1. Se user forçou um modelo (!= auto), respeita — desde que tenha cred.
- *   2. Code generation pesado → OpenAI (gpt-4.1); senão NVIDIA NIM (llama-70b).
- *   3. Sumarização rápida / Q&A factual → Groq (mais rápido); senão Gemini.
- *   4. Default: Claude (arquitetura, análise, raciocínio longo).
- *   5. Fallback: primeiro provider com cred (claude > openai > gemini > groq > nvidia).
+ *   2. Code generation pesado → NVIDIA NIM (llama-70b, gratuito).
+ *   3. Sumarização rápida / Q&A factual → Groq (mais rápido).
+ *   4. Fallback: primeiro provider com cred, gratuitos primeiro
+ *      (groq > nvidia > openai).
+ *
+ * bug_19d312f3: o default era Claude (API da Anthropic) e o Q&A rápido caía no
+ * Gemini quando faltava o Groq. Os dois saíram da lista única (vetados).
+ * Revisão do #104: o `auto` preferia a OpenAI (paga) na geração de código e no
+ * fallback, à frente do Groq e da NVIDIA. Agora ela só entra no `auto` quando
+ * nenhum provedor gratuito tem chave; quem a quer antes pede com `-m openai`.
  */
 export declare function routeModel(input: string, preferred: ModelId): ResolvedModel;
 /**