@korl3one/ccode 2.2.0 → 3.1.0

package/dist/ai/manager.js

@@ -1,14 +1,30 @@
 import * as path from 'path';
+import axios from 'axios';
 import { ClaudeAdapter } from './claude.js';
-import { OpenAIAdapter } from './openai.js';
 import { GeminiAdapter } from './gemini.js';
-import { DeepSeekAdapter } from './deepseek.js';
-import { GroqAdapter } from './groq.js';
-import { OllamaAdapter } from './ollama.js';
 import { FileUtils } from '../utils/files.js';
-/**
- * Gestiona la configuración y conexión con proveedores de IA.
- */
+export const PROVIDER_INFO = {
+    gemini: {
+        name: 'Google Gemini',
+        keyUrl: 'https://aistudio.google.com/apikey',
+        envVars: ['GOOGLE_API_KEY', 'GEMINI_API_KEY'],
+        models: [
+            { name: 'Gemini 2.5 Flash (recomendado, gratis)', value: 'gemini-2.5-flash' },
+            { name: 'Gemini 2.5 Pro (maxima calidad)', value: 'gemini-2.5-pro' },
+            { name: 'Gemini 2.0 Flash (rapido)', value: 'gemini-2.0-flash' },
+        ],
+    },
+    claude: {
+        name: 'Claude (Anthropic)',
+        keyUrl: 'https://console.anthropic.com/settings/keys',
+        envVars: ['ANTHROPIC_API_KEY'],
+        models: [
+            { name: 'Claude Sonnet 4 (recomendado)', value: 'claude-sonnet-4-20250514' },
+            { name: 'Claude Haiku 3.5 (rapido)', value: 'claude-haiku-4-5-20251001' },
+            { name: 'Claude Opus 4 (maxima calidad)', value: 'claude-opus-4-20250514' },
+        ],
+    },
+};
 export class AIManager {
     static CONFIG_FILE = '.ccode/config.json';
     static async loadConfig() {
@@ -24,18 +40,18 @@ export class AIManager {
     }
     static getProvider(config) {
         switch (config.provider) {
+            case 'gemini': {
+                const adapter = new GeminiAdapter({ apiKey: config.apiKey, model: config.model });
+                // If using OAuth from Gemini CLI
+                if (config.authType === 'oauth') {
+                    const token = GeminiAdapter.readOAuthToken();
+                    if (token)
+                        adapter.setOAuthToken(token);
+                }
+                return adapter;
+            }
             case 'claude':
                 return new ClaudeAdapter({ apiKey: config.apiKey, model: config.model });
-            case 'openai':
-                return new OpenAIAdapter({ apiKey: config.apiKey, model: config.model });
-            case 'gemini':
-                return new GeminiAdapter({ apiKey: config.apiKey, model: config.model });
-            case 'deepseek':
-                return new DeepSeekAdapter({ apiKey: config.apiKey, model: config.model });
-            case 'groq':
-                return new GroqAdapter({ apiKey: config.apiKey, model: config.model });
-            case 'ollama':
-                return new OllamaAdapter({ model: config.model, baseUrl: config.baseUrl });
             default:
                 throw new Error(`Proveedor desconocido: ${config.provider}`);
         }
@@ -43,11 +59,57 @@ export class AIManager {
     static async testConnection(config) {
         try {
             const provider = this.getProvider(config);
-            await provider.generate('Responde únicamente con la palabra "ok".');
-            return true;
+            const result = await provider.generate('Responde unicamente con la palabra "ok".');
+            if (!result || result.trim().length === 0) {
+                return { ok: false, error: 'La IA respondio pero el contenido esta vacio.' };
+            }
+            return { ok: true };
         }
-        catch {
-            return false;
+        catch (err) {
+            if (axios.isAxiosError(err)) {
+                const status = err.response?.status;
+                const data = err.response?.data;
+                if (status === 401 || status === 403) {
+                    return { ok: false, error: `Credenciales invalidas (HTTP ${status}). Verifica tu autenticacion.` };
+                }
+                if (status === 404) {
+                    return { ok: false, error: 'Modelo no encontrado. Verifica el nombre del modelo.' };
+                }
+                if (status === 429) {
+                    return { ok: false, error: 'Rate limit. Espera unos segundos e intenta de nuevo.' };
+                }
+                if (err.code === 'ECONNREFUSED' || err.code === 'ENOTFOUND') {
+                    return { ok: false, error: 'Sin conexion a internet.' };
+                }
+                if (err.code === 'ETIMEDOUT' || err.message?.includes('timeout')) {
+                    return { ok: false, error: 'Timeout: la IA no respondio a tiempo.' };
+                }
+                const msg = typeof data === 'object' && data?.error?.message
+                    ? data.error.message
+                    : `Error HTTP ${status || 'desconocido'}`;
+                return { ok: false, error: msg };
+            }
+            return { ok: false, error: err instanceof Error ? err.message : String(err) };
         }
     }
+    /**
+     * Auto-detect the best available provider.
+     * Priority: 1) Gemini CLI OAuth, 2) env vars, 3) null
+     */
+    static autoDetect() {
+        // 1. Gemini CLI installed and authenticated
+        if (GeminiAdapter.isAvailable()) {
+            return { provider: 'gemini', authType: 'oauth', source: 'Gemini CLI' };
+        }
+        // 2. Environment variables
+        for (const [provider, info] of Object.entries(PROVIDER_INFO)) {
+            for (const envVar of info.envVars) {
+                const value = process.env[envVar];
+                if (value && value.length > 10) {
+                    return { provider: provider, authType: 'api-key', apiKey: value, source: envVar };
+                }
+            }
+        }
+        return null;
+    }
 }

package/dist/cli/brand.js

@@ -27,7 +27,7 @@ export function showLogo() {
     LOGO_LINES.forEach((line, i) => {
         console.log(chalk.hex(GRADIENT[i])(line));
     });
-    console.log(c.dim('  Context-Persistent AI Development  v2.0'));
+    console.log(c.dim('  Context-Persistent AI Development  v3.0'));
     console.log('');
 }
 // ─── Componentes UI ─────────────────────────────────────────────────

package/dist/cli/index.js

@@ -4,12 +4,15 @@ import inquirer from 'inquirer';
 import ora from 'ora';
 import * as path from 'path';
 import * as fs from 'fs';
+import updateNotifier from 'update-notifier';
 import { showLogo, showWelcome, showHeader, showStep, showSuccess, showError, showWarning, showInfo, showFileTree, showProgressBar, c, } from './brand.js';
 import { FileUtils } from '../utils/files.js';
 import { ContextEngine } from '../core/context.js';
 import { TaskEngine } from '../core/tasks.js';
 import { PromptBuilder } from '../core/prompt-builder.js';
-import { AIManager } from '../ai/manager.js';
+import { AIManager, PROVIDER_INFO } from '../ai/manager.js';
+import { ContextExporter } from '../core/exports.js';
+import { exec } from 'child_process';
 import { FileWatcher, displayChanges } from './watcher.js';
 // ─── Estado global de sesión ────────────────────────────────────────
 const watcher = new FileWatcher();
@@ -32,84 +35,118 @@ async function requireAI() {
     }
     return config;
 }
+function openBrowser(url) {
+    const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    exec(`${cmd} "${url}"`);
+}
 async function promptAIConfig() {
-    const { provider } = await inquirer.prompt([{
+    // 1. Auto-detect — zero config if possible
+    const detected = AIManager.autoDetect();
+    if (detected) {
+        const info = PROVIDER_INFO[detected.provider];
+        showSuccess(`${info.name} detectado (${detected.source})`);
+        const testSpinner = ora({ text: 'Verificando conexion...', color: 'cyan', spinner: 'dots' }).start();
+        const defaultModel = info.models[0].value;
+        const config = {
+            provider: detected.provider,
+            apiKey: detected.apiKey,
+            model: defaultModel,
+            authType: detected.authType,
+        };
+        const testResult = await AIManager.testConnection(config);
+        if (testResult.ok) {
+            testSpinner.succeed(c.success(`Conectado a ${info.name}`));
+            const { model } = await inquirer.prompt([{
+                    type: 'select',
+                    name: 'model',
+                    message: 'Modelo:',
+                    choices: info.models,
+                }]);
+            config.model = model;
+            return config;
+        }
+        testSpinner.fail(c.error('Sesion expirada'));
+        if (detected.authType === 'oauth') {
+            showWarning('El token de Gemini CLI expiro.');
+            showInfo('Ejecuta "gemini" en otra terminal para refrescar tu sesion.');
+            showInfo('Luego vuelve a correr "ccode init".');
+            console.log('');
+            const { continueManual } = await inquirer.prompt([{
+                    type: 'confirm', name: 'continueManual',
+                    message: 'Configurar manualmente mientras tanto?', default: true,
+                }]);
+            if (!continueManual) {
+                throw new Error('Ejecuta "gemini" para refrescar tu sesion y vuelve a intentar.');
+            }
+        }
+        else {
+            showError(testResult.error || 'No se pudo conectar.');
+        }
+        console.log('');
+    }
+    // 2. Nothing detected — guide setup
+    showInfo('No se detecto ningun proveedor de IA.');
+    console.log('');
+    console.log(c.white('  Opciones para configurar:'));
+    console.log(c.accent('  1. Gemini CLI') + c.dim(' — Instala: npm i -g @anthropic-ai/gemini-cli'));
+    console.log(c.dim('     Luego ejecuta "gemini" una vez para autenticarte con Google.'));
+    console.log(c.accent('  2. Variable de entorno') + c.dim(' — export GOOGLE_API_KEY="tu-key"'));
+    console.log(c.accent('  3. Variable de entorno') + c.dim(' — export ANTHROPIC_API_KEY="tu-key"'));
+    console.log('');
+    const { method } = await inquirer.prompt([{
             type: 'select',
-            name: 'provider',
-            message: 'Proveedor de IA:',
+            name: 'method',
+            message: 'Como quieres configurar?',
             choices: [
-                { name: '  Claude (Anthropic) — Recomendado', value: 'claude' },
-                { name: '  OpenAI (ChatGPT)', value: 'openai' },
-                { name: '  Google Gemini', value: 'gemini' },
-                { name: '  DeepSeek', value: 'deepseek' },
-                { name: '  Groq (ultra-rápido)', value: 'groq' },
-                { name: '  Ollama (local, sin API key)', value: 'ollama' },
+                { name: '  Tengo una API Key de Gemini (Google)', value: 'gemini-key' },
+                { name: '  Tengo una API Key de Claude (Anthropic)', value: 'claude-key' },
+                { name: '  Obtener API Key de Gemini gratis (abre navegador)', value: 'gemini-browser' },
+                { name: '  Obtener API Key de Claude (abre navegador)', value: 'claude-browser' },
             ],
         }]);
-    const config = { provider };
-    // Modelos por proveedor
-    const modelChoices = {
-        claude: [
-            { name: 'Claude Sonnet 4 (recomendado)', value: 'claude-sonnet-4-20250514' },
-            { name: 'Claude Haiku 3.5 (rápido)', value: 'claude-haiku-4-5-20251001' },
-            { name: 'Claude Opus 4 (máxima calidad)', value: 'claude-opus-4-20250514' },
-        ],
-        openai: [
-            { name: 'GPT-4o (recomendado)', value: 'gpt-4o' },
-            { name: 'GPT-4o mini (rápido)', value: 'gpt-4o-mini' },
-            { name: 'GPT-4.1 (último)', value: 'gpt-4.1' },
-            { name: 'o3-mini (razonamiento)', value: 'o3-mini' },
-        ],
-        gemini: [
-            { name: 'Gemini 2.5 Flash (recomendado)', value: 'gemini-2.5-flash' },
-            { name: 'Gemini 2.5 Pro (máxima calidad)', value: 'gemini-2.5-pro' },
-            { name: 'Gemini 2.0 Flash (rápido)', value: 'gemini-2.0-flash' },
-        ],
-        deepseek: [
-            { name: 'DeepSeek Chat (recomendado)', value: 'deepseek-chat' },
-            { name: 'DeepSeek Reasoner', value: 'deepseek-reasoner' },
-        ],
-        groq: [
-            { name: 'Llama 3.3 70B (recomendado)', value: 'llama-3.3-70b-versatile' },
-            { name: 'Llama 3.1 8B (rápido)', value: 'llama-3.1-8b-instant' },
-            { name: 'Mixtral 8x7B', value: 'mixtral-8x7b-32768' },
-        ],
-    };
-    // API Key (todos excepto Ollama)
-    if (provider !== 'ollama') {
-        const providerNames = {
-            claude: 'Anthropic', openai: 'OpenAI', gemini: 'Google AI',
-            deepseek: 'DeepSeek', groq: 'Groq',
-        };
-        const { apiKey } = await inquirer.prompt([{
-                type: 'password',
-                name: 'apiKey',
-                message: `API Key de ${providerNames[provider]}:`,
-                mask: '*',
-                validate: (v) => v.length > 10 || 'Ingresa una API Key válida',
-            }]);
-        config.apiKey = apiKey;
-    }
-    // Selección de modelo
-    if (provider === 'ollama') {
-        const { model } = await inquirer.prompt([{
-                type: 'input',
-                name: 'model',
-                message: 'Modelo de Ollama:',
-                default: 'llama3',
-            }]);
-        config.model = model;
+    const isGemini = method.startsWith('gemini');
+    const provider = isGemini ? 'gemini' : 'claude';
+    const info = PROVIDER_INFO[provider];
+    // Open browser if needed
+    if (method.endsWith('-browser')) {
+        openBrowser(info.keyUrl);
+        showInfo('Se abrio el navegador. Copia tu API Key y pegala aqui.');
+        console.log('');
     }
-    else {
-        const { model } = await inquirer.prompt([{
-                type: 'select',
-                name: 'model',
-                message: 'Modelo:',
-                choices: modelChoices[provider],
-            }]);
-        config.model = model;
+    const { apiKey } = await inquirer.prompt([{
+            type: 'password',
+            name: 'apiKey',
+            message: `API Key de ${info.name}:`,
+            mask: '*',
+            validate: (v) => v.length > 10 || 'API Key muy corta',
+        }]);
+    const { model } = await inquirer.prompt([{
+            type: 'select',
+            name: 'model',
+            message: 'Modelo:',
+            choices: info.models,
+        }]);
+    const config = { provider, apiKey, model, authType: 'api-key' };
+    const testSpinner = ora({ text: 'Verificando conexion...', color: 'cyan', spinner: 'dots' }).start();
+    const result = await AIManager.testConnection(config);
+    if (result.ok) {
+        testSpinner.succeed(c.success('Conexion verificada'));
+        const envVar = info.envVars[0];
+        showInfo(`Tip: Para que sea automatico la proxima vez:`);
+        console.log(c.accent(`    export ${envVar}="tu-api-key"`));
+        console.log(c.dim('    Agrega esa linea a tu ~/.zshrc o ~/.bashrc'));
+        console.log('');
+        return config;
     }
-    return config;
+    testSpinner.fail(c.error('Error de conexion'));
+    showError(result.error || 'No se pudo conectar.');
+    const { retry } = await inquirer.prompt([{
+            type: 'confirm', name: 'retry',
+            message: 'Intentar de nuevo?', default: true,
+        }]);
+    if (retry)
+        return promptAIConfig();
+    throw new Error('Configuracion de IA cancelada.');
 }
 function listProjectFiles(dir, prefix = '') {
     const results = [];
@@ -179,7 +216,7 @@ async function startSession() {
         if (!hasConfig) {
             choices.push({ name: '  🔌  Conectar proveedor de IA', value: 'connect' });
         }
-        choices.push({ name: '  📋  Generar / actualizar plan de tareas', value: 'plan' }, { name: `  📊  Ver estado completo`, value: 'status' }, { name: '  📄  Ver contexto generado', value: 'context' }, { name: '  🔄  Actualizar contexto (re-analizar proyecto)', value: 'update' }, { name: '  📤  Exportar contexto para otra IA', value: 'export' }, { name: '  💡  Explicar proyecto (resumen rápido)', value: 'explain' }, { name: '  🩺  Doctor (diagnóstico de salud)', value: 'doctor' });
+        choices.push({ name: '  📋  Generar / actualizar plan de tareas', value: 'plan' }, { name: `  📊  Ver estado completo`, value: 'status' }, { name: '  📄  Ver contexto generado', value: 'context' }, { name: '  🔄  Actualizar contexto (re-analizar proyecto)', value: 'update' }, { name: '  🔗  Sincronizar contexto (AGENTS.md, CLAUDE.md, ...)', value: 'sync' }, { name: '  📤  Exportar contexto para otra IA', value: 'export' }, { name: '  💡  Explicar proyecto (resumen rápido)', value: 'explain' }, { name: '  🩺  Doctor (diagnóstico de salud)', value: 'doctor' });
         if (hasConfig) {
             choices.push({ name: '  🔌  Reconfigurar IA', value: 'connect' });
         }
@@ -212,6 +249,7 @@ async function startSession() {
             status: handleStatus,
             context: handleContext,
             update: handleUpdate,
+            sync: handleSync,
             export: handleExport,
             explain: handleExplain,
             doctor: handleDoctor,
@@ -341,6 +379,19 @@ async function handleInit() {
             { name: 'config.json    ', desc: `IA: ${aiConfig.provider}` },
         ]);
         console.log('');
+        // ─── Sincronizar contexto a todas las herramientas AI ───
+        const syncSpinner = ora({ text: 'Sincronizando contexto con herramientas AI...', color: 'cyan', spinner: 'dots' }).start();
+        try {
+            const exporter = new ContextExporter();
+            const exported = await exporter.exportAll();
+            syncSpinner.succeed(c.success('Contexto sincronizado'));
+            console.log(c.dim('\n  Archivos de contexto generados:\n'));
+            showFileTree(exported.map(e => ({ name: e.file, desc: e.label.split('(')[1]?.replace(')', '') || '' })));
+            console.log('');
+        }
+        catch {
+            syncSpinner.warn(c.warning('No se pudo sincronizar (los archivos .ccode/ se crearon correctamente)'));
+        }
         showSuccess('CCODE se queda activo observando tu proyecto.');
         showInfo('Abre otra terminal y empieza a desarrollar.');
         showInfo('CCODE detectará los cambios automáticamente.');
@@ -384,17 +435,9 @@ async function handleConnect() {
             return;
     }
     const config = await promptAIConfig();
-    const spinner = ora({ text: 'Verificando conexión...', color: 'cyan', spinner: 'dots' }).start();
-    const success = await AIManager.testConnection(config);
-    if (success) {
-        spinner.succeed(c.success('Conexión verificada'));
-        await AIManager.saveConfig(config);
-        showSuccess('Configuración guardada.');
-    }
-    else {
-        spinner.fail(c.error('No se pudo conectar'));
-        showError('Verifica tu API Key, conexión a internet, o que Ollama esté corriendo.');
-    }
+    // promptAIConfig already verifies connection, just save
+    await AIManager.saveConfig(config);
+    showSuccess('Configuracion guardada.');
 }
 // ─── PLAN ───────────────────────────────────────────────────────────
 async function handlePlan() {
@@ -780,6 +823,50 @@ Responde ÚNICAMENTE con JSON válido:
             console.log(c.accent('  Cambios detectados:'));
             result.changes.forEach(change => console.log(c.dim(`    • ${change}`)));
         }
+        // Sincronizar exports después de actualizar contexto
+        const syncSpinner = ora({ text: 'Sincronizando exports...', color: 'cyan', spinner: 'dots' }).start();
+        try {
+            const exporter = new ContextExporter();
+            const existing = await exporter.detectExisting();
+            if (existing.length > 0) {
+                for (const format of existing) {
+                    await exporter.exportFormat(format);
+                }
+                syncSpinner.succeed(c.success(`${existing.length} export${existing.length > 1 ? 's' : ''} actualizado${existing.length > 1 ? 's' : ''}`));
+            }
+            else {
+                syncSpinner.info(c.dim('Sin exports previos. Usa "export" para generarlos.'));
+            }
+        }
+        catch {
+            syncSpinner.warn(c.warning('No se pudieron actualizar los exports'));
+        }
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Error');
+        showError(error instanceof Error ? error.message : String(error));
+    }
+}
+// ─── SYNC ──────────────────────────────────────────────────────────
+async function handleSync() {
+    if (!(await requireInit()))
+        return;
+    showHeader('Sincronizar Contexto', 'Genera archivos de contexto para cada herramienta AI');
+    const exporter = new ContextExporter();
+    const existing = await exporter.detectExisting();
+    if (existing.length > 0) {
+        showInfo(`Exports existentes: ${existing.map(f => ContextExporter.FORMATS[f].file).join(', ')}`);
+    }
+    const spinner = ora({ text: 'Generando archivos de contexto...', color: 'cyan', spinner: 'dots' }).start();
+    try {
+        const exported = await exporter.exportAll();
+        spinner.succeed(c.success('Contexto sincronizado con todas las herramientas'));
+        console.log('');
+        showFileTree(exported.map(e => ({ name: e.file, desc: e.label.split('(')[1]?.replace(')', '') || '' })));
+        console.log('');
+        showInfo('Cada herramienta AI leera su archivo automaticamente.');
+        showInfo('Los archivos se actualizan con cada "sync", "update" o "init".');
         console.log('');
     }
     catch (error) {
@@ -792,12 +879,61 @@ async function handleExport() {
     if (!(await requireInit()))
         return;
     showHeader('Exportar Contexto');
-    const pb = new PromptBuilder();
-    const fullContext = await pb.buildContextPrompt();
-    const exportPath = path.join(process.cwd(), '.ccode', 'context-export.md');
-    await FileUtils.writeFile(exportPath, `# CCODE — Project Context Export\n\n${fullContext}`);
-    showSuccess('Contexto exportado a .ccode/context-export.md');
-    showInfo('Copia el contenido y pégalo en cualquier chat de IA (ChatGPT, Claude, Gemini, etc.).');
+    const { mode } = await inquirer.prompt([{
+            type: 'select',
+            name: 'mode',
+            message: 'Tipo de export:',
+            choices: [
+                { name: '  Sincronizar con todas las herramientas AI', value: 'all' },
+                { name: '  Solo export universal (.md para copiar/pegar)', value: 'universal' },
+                { name: '  Elegir herramientas específicas', value: 'pick' },
+            ],
+        }]);
+    const exporter = new ContextExporter();
+    if (mode === 'universal') {
+        const content = await exporter.generateUniversalExport();
+        const exportPath = path.join(process.cwd(), '.ccode', 'context-export.md');
+        await FileUtils.writeFile(exportPath, content);
+        showSuccess('Contexto exportado a .ccode/context-export.md');
+        showInfo('Copia el contenido y pegalo en cualquier chat de IA.');
+        console.log('');
+        return;
+    }
+    if (mode === 'pick') {
+        const formats = Object.entries(ContextExporter.FORMATS);
+        const existing = await exporter.detectExisting();
+        const { selected } = await inquirer.prompt([{
+                type: 'checkbox',
+                name: 'selected',
+                message: 'Selecciona los formatos:',
+                choices: formats.map(([key, info]) => ({
+                    name: `  ${info.label}${existing.includes(key) ? c.dim(' (existe)') : ''}`,
+                    value: key,
+                    checked: true,
+                })),
+            }]);
+        if (selected.length === 0) {
+            showWarning('No se selecciono ningun formato.');
+            return;
+        }
+        const spinner = ora({ text: 'Generando exports...', color: 'cyan', spinner: 'dots' }).start();
+        for (const format of selected) {
+            await exporter.exportFormat(format);
+        }
+        spinner.succeed(c.success(`${selected.length} formato${selected.length > 1 ? 's' : ''} exportado${selected.length > 1 ? 's' : ''}`));
+        for (const format of selected) {
+            const info = ContextExporter.FORMATS[format];
+            console.log(c.dim(`    ${info.file}`));
+        }
+        console.log('');
+        return;
+    }
+    // mode === 'all'
+    const spinner = ora({ text: 'Sincronizando con todas las herramientas AI...', color: 'cyan', spinner: 'dots' }).start();
+    const exported = await exporter.exportAll();
+    spinner.succeed(c.success('Contexto sincronizado'));
+    console.log(c.dim('\n  Archivos generados:\n'));
+    showFileTree(exported.map(e => ({ name: e.file, desc: e.label.split('(')[1]?.replace(')', '') || '' })));
     console.log('');
 }
 // ─── EXPLAIN ────────────────────────────────────────────────────────
@@ -877,14 +1013,15 @@ async function handleDoctor() {
     const config = await AIManager.loadConfig();
     if (config) {
         console.log(c.success(`  ✓ Configurado: ${config.provider} (${config.model || 'default'})`));
-        // Test de conexión
-        const spinner = ora({ text: '  Probando conexión...', color: 'cyan', spinner: 'dots' }).start();
-        const connected = await AIManager.testConnection(config);
-        if (connected) {
-            spinner.succeed(c.success('Conexión activa'));
+        // Test de conexion
+        const spinner = ora({ text: '  Probando conexion...', color: 'cyan', spinner: 'dots' }).start();
+        const connResult = await AIManager.testConnection(config);
+        if (connResult.ok) {
+            spinner.succeed(c.success('Conexion activa'));
         }
         else {
             spinner.fail(c.error('No se pudo conectar'));
+            showError(`  ${connResult.error}`);
             issues++;
         }
     }
@@ -915,7 +1052,26 @@ async function handleDoctor() {
             issues++;
         }
     }
-    // 4. Archivos del proyecto
+    // 4. Exports de contexto
+    console.log('');
+    console.log(c.bold('  Exports de contexto'));
+    const exporter = new ContextExporter();
+    const existingExports = await exporter.detectExisting();
+    if (existingExports.length > 0) {
+        for (const format of existingExports) {
+            const info = ContextExporter.FORMATS[format];
+            console.log(c.success(`  ✓ ${info.file}`));
+        }
+        const missing = Object.keys(ContextExporter.FORMATS).length - existingExports.length;
+        if (missing > 0) {
+            console.log(c.dim(`  ${missing} formato${missing > 1 ? 's' : ''} disponible${missing > 1 ? 's' : ''} sin generar`));
+        }
+    }
+    else {
+        console.log(c.warning('  ⚠ Sin exports — ejecuta "Sincronizar contexto" para generarlos'));
+        issues++;
+    }
+    // 5. Archivos del proyecto
     console.log('');
     console.log(c.bold('  Proyecto'));
     const projectFiles = listProjectFiles(process.cwd());
@@ -935,11 +1091,15 @@ async function handleDoctor() {
 }
 // ─── CLI Setup ──────────────────────────────────────────────────────
 async function main() {
+    // Notificar si hay una version nueva disponible
+    const pkg = JSON.parse(fs.readFileSync(new URL('../../package.json', import.meta.url), 'utf-8'));
+    const notifier = updateNotifier({ pkg, updateCheckInterval: 1000 * 60 * 60 * 4 }); // cada 4 horas
+    notifier.notify({ isGlobal: true });
     const program = new Command();
     program
         .name('ccode')
         .description('CCODE: Contexto Persistente para Desarrollo con IA')
-        .version('2.2.0');
+        .version(pkg.version);
     // Comandos individuales (para uso rápido sin sesión)
     program.command('init').description('Inicializa el contexto del proyecto').action(async () => {
         await handleInit();
@@ -954,6 +1114,7 @@ async function main() {
     program.command('status').description('Estado del proyecto').action(handleStatus);
     program.command('context').description('Ver contexto generado').action(handleContext);
     program.command('update').description('Re-analiza y actualiza el contexto').action(handleUpdate);
+    program.command('sync').description('Sincroniza contexto con todas las herramientas AI').action(handleSync);
     program.command('export').description('Exporta contexto como .md para cualquier IA').action(handleExport);
     program.command('explain').description('Resumen rápido del proyecto').action(handleExplain);
     program.command('doctor').description('Diagnóstico de salud del proyecto').action(handleDoctor);

package/dist/core/exports.d.ts

@@ -0,0 +1,74 @@
+/**
+ * ContextExporter: genera archivos de contexto para cada herramienta de IA.
+ *
+ * Lee la fuente de verdad (.ccode/) y produce exports específicos:
+ * - AGENTS.md      → Estándar abierto (Linux Foundation)
+ * - CLAUDE.md      → Claude Code
+ * - GEMINI.md      → Gemini CLI
+ * - .cursorrules   → Cursor
+ * - copilot-instructions.md → GitHub Copilot
+ *
+ * Cada export se adapta al formato y expectativas de la herramienta destino.
+ */
+export declare class ContextExporter {
+    private readonly ccodePath;
+    private readonly projectRoot;
+    static readonly FORMATS: Record<string, {
+        file: string;
+        label: string;
+    }>;
+    constructor(projectRoot?: string);
+    /**
+     * Lee todos los archivos de contexto de .ccode/
+     */
+    private readSources;
+    /**
+     * Formatea las tareas como lista legible.
+     */
+    private formatTasks;
+    /**
+     * Genera AGENTS.md — Estándar abierto compatible con múltiples herramientas.
+     * Sigue la convención de AGENTS.md (Linux Foundation / AAIF).
+     */
+    generateAgentsMd(): Promise<string>;
+    /**
+     * Genera CLAUDE.md — Optimizado para Claude Code.
+     * Claude Code lee este archivo automáticamente del root del proyecto.
+     */
+    generateClaudeMd(): Promise<string>;
+    /**
+     * Genera GEMINI.md — Para Gemini CLI.
+     */
+    generateGeminiMd(): Promise<string>;
+    /**
+     * Genera .cursorrules — Instrucciones para Cursor IDE.
+     * Cursor lee este archivo del root del proyecto automáticamente.
+     */
+    generateCursorRules(): Promise<string>;
+    /**
+     * Genera copilot-instructions.md — Para GitHub Copilot.
+     * Se ubica en .github/copilot-instructions.md
+     */
+    generateCopilotInstructions(): Promise<string>;
+    /**
+     * Genera el export universal (.ccode/context-export.md).
+     */
+    generateUniversalExport(): Promise<string>;
+    /**
+     * Genera y escribe un formato específico.
+     */
+    exportFormat(format: string): Promise<string>;
+    /**
+     * Exporta todos los formatos de una vez.
+     * Retorna la lista de archivos generados.
+     */
+    exportAll(): Promise<Array<{
+        format: string;
+        file: string;
+        label: string;
+    }>>;
+    /**
+     * Verifica qué formatos ya existen en el proyecto.
+     */
+    detectExisting(): Promise<string[]>;
+}