@korl3one/ccode 2.0.0

package/dist/cli/index.js

@@ -0,0 +1,737 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import * as path from 'path';
+import * as fs from 'fs';
+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 { FileWatcher, displayChanges } from './watcher.js';
+// ─── Estado global de sesión ────────────────────────────────────────
+const watcher = new FileWatcher();
+// ─── Helpers ────────────────────────────────────────────────────────
+async function requireInit() {
+    const ccodeDir = path.join(process.cwd(), '.ccode');
+    if (!(await FileUtils.exists(ccodeDir))) {
+        showError('Proyecto no inicializado.');
+        showInfo('Ejecuta: ccode init');
+        return false;
+    }
+    return true;
+}
+async function requireAI() {
+    const config = await AIManager.loadConfig();
+    if (!config) {
+        showError('Proveedor de IA no configurado.');
+        showInfo('Ejecuta: ccode connect');
+        return null;
+    }
+    return config;
+}
+async function promptAIConfig() {
+    const { provider } = await inquirer.prompt([{
+            type: 'select',
+            name: 'provider',
+            message: 'Proveedor de IA:',
+            choices: [
+                { name: '  Claude (Anthropic) — Recomendado', value: 'claude' },
+                { name: '  Ollama (Local)', value: 'ollama' },
+            ],
+        }]);
+    const config = { provider };
+    if (provider === 'claude') {
+        const { apiKey } = await inquirer.prompt([{
+                type: 'password',
+                name: 'apiKey',
+                message: 'API Key de Anthropic:',
+                mask: '*',
+                validate: (v) => v.length > 10 || 'Ingresa una API Key válida',
+            }]);
+        config.apiKey = apiKey;
+        const { model } = await inquirer.prompt([{
+                type: 'select',
+                name: 'model',
+                message: 'Modelo:',
+                choices: [
+                    { 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' },
+                ],
+            }]);
+        config.model = model;
+    }
+    else {
+        const { model } = await inquirer.prompt([{
+                type: 'input',
+                name: 'model',
+                message: 'Modelo de Ollama:',
+                default: 'llama3',
+            }]);
+        config.model = model;
+    }
+    return config;
+}
+function listProjectFiles(dir, prefix = '') {
+    const results = [];
+    const ignore = ['node_modules', '.ccode', '.git', 'dist', '.next', '__pycache__', '.venv'];
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (ignore.includes(entry.name) || entry.name.startsWith('.'))
+                continue;
+            const fullPath = path.join(prefix, entry.name);
+            if (entry.isDirectory()) {
+                results.push(`${fullPath}/`);
+                results.push(...listProjectFiles(path.join(dir, entry.name), fullPath));
+            }
+            else {
+                results.push(fullPath);
+            }
+            if (results.length > 100)
+                break;
+        }
+    }
+    catch { /* ignore */ }
+    return results;
+}
+// ─── SESIÓN PERSISTENTE ─────────────────────────────────────────────
+async function startSession() {
+    // Iniciar watcher
+    watcher.start(process.cwd());
+    let running = true;
+    while (running) {
+        // Cargar estado actual
+        const taskEngine = new TaskEngine();
+        await taskEngine.load();
+        const stats = taskEngine.getStats();
+        const hasConfig = await AIManager.loadConfig();
+        const contextEngine = new ContextEngine();
+        const isLoaded = await contextEngine.load();
+        const state = isLoaded ? contextEngine.getState() : null;
+        const currentTask = state?.current_task_id
+            ? taskEngine.getTaskById(state.current_task_id)
+            : null;
+        // Mostrar cambios detectados
+        const changedFiles = watcher.flush();
+        if (changedFiles.length > 0) {
+            displayChanges(changedFiles);
+        }
+        // Mostrar estado actual compacto
+        if (stats.total > 0) {
+            console.log(c.dim(`  ${showProgressBar(stats.completed, stats.total)}`));
+        }
+        if (currentTask) {
+            console.log(c.accent(`  ▶ Tarea activa: ${currentTask.id} — ${currentTask.title}`));
+        }
+        console.log('');
+        // Construir menú contextual
+        const choices = [];
+        // Si hay cambios recientes y tarea activa → sugerir verificación primero
+        if (changedFiles.length > 0 && currentTask) {
+            choices.push({ name: c.accent('  🔍  Verificar progreso (se detectaron cambios)'), value: 'verify' });
+        }
+        if (currentTask) {
+            choices.push({ name: '  ✅  Marcar tarea como completada', value: 'complete' }, { name: '  🔍  Verificar progreso con IA', value: 'verify' });
+        }
+        else if (stats.pending > 0) {
+            choices.push({ name: `  ▶   Iniciar siguiente tarea (${stats.pending} pendientes)`, value: 'next' });
+        }
+        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' });
+        if (hasConfig) {
+            choices.push({ name: '  🔌  Reconfigurar IA', value: 'connect' });
+        }
+        choices.push({ name: '  🚪  Salir', value: 'exit' });
+        // Eliminar duplicados por value
+        const seen = new Set();
+        const uniqueChoices = choices.filter(ch => {
+            if (seen.has(ch.value))
+                return false;
+            seen.add(ch.value);
+            return true;
+        });
+        const { action } = await inquirer.prompt([{
+                type: 'select',
+                name: 'action',
+                message: '¿Qué hacemos?',
+                choices: uniqueChoices,
+            }]);
+        if (action === 'exit') {
+            running = false;
+            continue;
+        }
+        const handlers = {
+            init: handleInit,
+            connect: handleConnect,
+            plan: handlePlan,
+            next: handleNext,
+            verify: handleVerify,
+            complete: handleComplete,
+            status: handleStatus,
+            context: handleContext,
+        };
+        if (handlers[action]) {
+            try {
+                await handlers[action]();
+            }
+            catch (err) {
+                showError(err instanceof Error ? err.message : String(err));
+                showInfo('La sesión sigue activa. Puedes intentar otra acción.');
+            }
+        }
+        // Pequeña pausa visual entre acciones
+        console.log('');
+        console.log(c.dim('  ─────────────────────────────────────────────'));
+        console.log(c.dim('  CCODE sigue observando tu proyecto...'));
+        console.log('');
+    }
+    watcher.stop();
+    console.log(c.dim('\n  Sesión finalizada. Hasta pronto!\n'));
+}
+// ─── INIT ───────────────────────────────────────────────────────────
+async function handleInit() {
+    showLogo();
+    console.log(c.accent('  Asistente de Inicialización de Proyecto'));
+    console.log(c.dim('  CCODE genera el contexto de trabajo, no el código.\n'));
+    const ccodeDir = path.join(process.cwd(), '.ccode');
+    if (await FileUtils.exists(ccodeDir)) {
+        showWarning('Este proyecto ya ha sido inicializado.');
+        showInfo('Usa "plan" para regenerar el plan de tareas.');
+        return;
+    }
+    // ─ Paso 1
+    showStep(1, 4, 'Tu Proyecto');
+    console.log(c.dim('  Cuéntanos sobre tu proyecto. CCODE adaptará la'));
+    console.log(c.dim('  complejidad del contexto automáticamente.\n'));
+    const projectAnswers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Nombre del proyecto:',
+            default: path.basename(process.cwd()),
+            validate: (v) => v.trim().length > 0 || 'Requerido',
+        },
+        {
+            type: 'input',
+            name: 'description',
+            message: 'Describe tu proyecto (qué es y qué problema resuelve):',
+            validate: (v) => v.trim().length > 10 || 'Sé más descriptivo',
+        },
+        {
+            type: 'input',
+            name: 'features',
+            message: 'Funcionalidades principales (separadas por coma):',
+            validate: (v) => v.trim().length > 0 || 'Indica al menos una',
+        },
+    ]);
+    // ─ Paso 2
+    showStep(2, 4, 'Stack Técnico');
+    const techAnswers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'techStack',
+            message: 'Stack tecnológico (ej: React, Node.js, PostgreSQL):',
+            validate: (v) => v.trim().length > 0 || 'Requerido',
+        },
+        {
+            type: 'select',
+            name: 'projectType',
+            message: 'Tipo de proyecto:',
+            choices: ['Web App', 'Mobile App', 'API / Backend', 'CLI', 'Librería / SDK', 'Full Stack', 'Otro'],
+        },
+    ]);
+    // ─ Paso 3
+    showStep(3, 4, 'Conexión con IA');
+    console.log(c.dim('  Necesitamos IA para generar el contexto.\n'));
+    const aiConfig = await promptAIConfig();
+    // ─ Paso 4
+    showStep(4, 4, 'Generando Contexto');
+    const spinner = ora({ text: 'Conectando con IA...', color: 'cyan', spinner: 'dots' }).start();
+    try {
+        await FileUtils.ensureDir(ccodeDir);
+        await AIManager.saveConfig(aiConfig);
+        spinner.text = 'Analizando proyecto y generando contexto...';
+        const provider = AIManager.getProvider(aiConfig);
+        const metaPrompt = PromptBuilder.getContextGenerationPrompt(projectAnswers.name, projectAnswers.description, projectAnswers.features, techAnswers.techStack, techAnswers.projectType);
+        const response = await provider.generate(metaPrompt);
+        spinner.text = 'Procesando...';
+        const generated = PromptBuilder.parseJSON(response);
+        spinner.text = 'Creando estructura...';
+        const contextData = {
+            name: generated.project_name || projectAnswers.name,
+            version: '1.0.0',
+            architecture_file: 'architecture.md',
+            rules_file: 'rules.md',
+            tasks_file: 'tasks.json',
+        };
+        await FileUtils.writeJson(path.join(ccodeDir, 'context.json'), contextData);
+        await FileUtils.writeFile(path.join(ccodeDir, 'project.md'), generated.project);
+        await FileUtils.writeFile(path.join(ccodeDir, 'architecture.md'), generated.architecture);
+        await FileUtils.writeFile(path.join(ccodeDir, 'rules.md'), generated.rules);
+        const tasks = (generated.tasks || []).map((t, i) => ({
+            id: `TASK-${String(i + 1).padStart(3, '0')}`,
+            title: t.title,
+            description: t.description,
+            status: 'pending',
+            priority: (['high', 'medium', 'low'].includes(t.priority) ? t.priority : 'medium'),
+            module: t.module || 'general',
+        }));
+        await FileUtils.writeJson(path.join(ccodeDir, 'tasks.json'), { tasks });
+        await FileUtils.writeJson(path.join(ccodeDir, 'state.json'), {
+            current_task_id: null, workflow_stage: 'planned',
+        });
+        await FileUtils.writeFile(path.join(ccodeDir, 'memory.md'), `# Memoria del Proyecto\n\n## Decisiones\n\n### Inicialización — ${new Date().toISOString().split('T')[0]}\n- Proyecto **${contextData.name}** creado con CCODE\n- Complejidad: ${generated.complexity || 'auto'}\n- Stack: ${techAnswers.techStack}\n- Tipo: ${techAnswers.projectType}\n- ${tasks.length} tareas generadas\n`);
+        await FileUtils.writeFile(path.join(ccodeDir, 'onboarding.md'), `# Guía de Onboarding\n\nCCODE mantiene el contexto del proyecto en .ccode/\nNo genera código — genera documentación, arquitectura y tareas.\n\n## Flujo\n1. CCODE te muestra la siguiente tarea\n2. Tú desarrollas con tu herramienta favorita\n3. CCODE detecta cambios y verifica progreso\n4. Cuando se cumple una tarea, la marca automáticamente\n`);
+        await FileUtils.writeFile(path.join(ccodeDir, 'user-prompt.md'), `# Prompt Original\n\n## Descripción\n${projectAnswers.description}\n\n## Funcionalidades\n${projectAnswers.features}\n\n## Stack\n${techAnswers.techStack}\n\n## Tipo\n${techAnswers.projectType}\n`);
+        spinner.succeed(c.success('Contexto generado'));
+        showHeader('Proyecto Listo', `${contextData.name} — ${generated.complexity || 'auto'}`);
+        console.log(c.dim('  Archivos de contexto en .ccode/:\n'));
+        showFileTree([
+            { name: 'project.md     ', desc: 'Documentación' },
+            { name: 'architecture.md', desc: 'Arquitectura' },
+            { name: 'rules.md       ', desc: 'Reglas' },
+            { name: 'tasks.json     ', desc: `${tasks.length} tareas` },
+            { name: 'memory.md      ', desc: 'Historial' },
+            { name: 'config.json    ', desc: `IA: ${aiConfig.provider}` },
+        ]);
+        console.log('');
+        showSuccess('CCODE se queda activo observando tu proyecto.');
+        showInfo('Abre otra terminal y empieza a desarrollar.');
+        showInfo('CCODE detectará los cambios automáticamente.');
+    }
+    catch (error) {
+        spinner.fail('Error durante la generación');
+        const errMsg = error instanceof Error ? error.message : String(error);
+        showError(errMsg);
+        showWarning('Creando estructura básica...');
+        if (!(await FileUtils.exists(ccodeDir)))
+            await FileUtils.ensureDir(ccodeDir);
+        await FileUtils.writeJson(path.join(ccodeDir, 'context.json'), {
+            name: projectAnswers.name, version: '1.0.0',
+            architecture_file: 'architecture.md', rules_file: 'rules.md', tasks_file: 'tasks.json',
+        });
+        await FileUtils.writeJson(path.join(ccodeDir, 'tasks.json'), { tasks: [] });
+        await FileUtils.writeJson(path.join(ccodeDir, 'state.json'), { current_task_id: null, workflow_stage: 'created' });
+        await FileUtils.writeFile(path.join(ccodeDir, 'project.md'), `# ${projectAnswers.name}\n\n${projectAnswers.description}\n`);
+        await FileUtils.writeFile(path.join(ccodeDir, 'architecture.md'), `# Arquitectura\n\nStack: ${techAnswers.techStack}\n`);
+        await FileUtils.writeFile(path.join(ccodeDir, 'rules.md'), '# Reglas\n\n(Pendiente)\n');
+        await FileUtils.writeFile(path.join(ccodeDir, 'memory.md'), '# Memoria\n');
+        await FileUtils.writeFile(path.join(ccodeDir, 'onboarding.md'), '# Onboarding\n');
+        showSuccess('Estructura básica creada.');
+    }
+    // ─── NO salir → entrar a sesión persistente ───
+    // (se ejecuta después del init, la sesión queda activa)
+}
+// ─── CONNECT ────────────────────────────────────────────────────────
+async function handleConnect() {
+    if (!(await requireInit()))
+        return;
+    showHeader('Configuración de IA');
+    const existingConfig = await AIManager.loadConfig();
+    if (existingConfig) {
+        showInfo(`Actual: ${existingConfig.provider} (${existingConfig.model || 'default'})`);
+        const { reconfigure } = await inquirer.prompt([{
+                type: 'confirm', name: 'reconfigure',
+                message: '¿Reconfigurar?', default: false,
+            }]);
+        if (!reconfigure)
+            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 credenciales o que Ollama esté corriendo.');
+    }
+}
+// ─── PLAN ───────────────────────────────────────────────────────────
+async function handlePlan() {
+    if (!(await requireInit()))
+        return;
+    const config = await requireAI();
+    if (!config)
+        return;
+    showHeader('Plan de Tareas');
+    const taskEngine = new TaskEngine();
+    await taskEngine.load();
+    const currentTasks = taskEngine.getTasks();
+    const stats = taskEngine.getStats();
+    if (currentTasks.length > 0) {
+        showInfo(`Tareas: ${stats.completed} completadas, ${stats.pending} pendientes`);
+        const { action } = await inquirer.prompt([{
+                type: 'select', name: 'action',
+                message: '¿Qué hacer?',
+                choices: [
+                    { name: '  Regenerar (mantiene completadas)', value: 'regenerate' },
+                    { name: '  Cancelar', value: 'cancel' },
+                ],
+            }]);
+        if (action === 'cancel')
+            return;
+    }
+    const { extraContext } = await inquirer.prompt([{
+            type: 'input', name: 'extraContext',
+            message: 'Requisitos adicionales (Enter para omitir):',
+        }]);
+    const spinner = ora({ text: 'Generando tareas...', color: 'cyan', spinner: 'dots' }).start();
+    try {
+        const ccodePath = path.join(process.cwd(), '.ccode');
+        const projectMd = await FileUtils.readFileSafe(path.join(ccodePath, 'project.md'));
+        const archMd = await FileUtils.readFileSafe(path.join(ccodePath, 'architecture.md'));
+        const rulesMd = await FileUtils.readFileSafe(path.join(ccodePath, 'rules.md'));
+        const provider = AIManager.getProvider(config);
+        const planPrompt = PromptBuilder.getPlanRegenerationPrompt(projectMd, archMd, rulesMd, currentTasks, extraContext);
+        const response = await provider.generate(planPrompt);
+        const generated = PromptBuilder.parseJSON(response);
+        const completedTasks = currentTasks.filter(t => t.status === 'completed');
+        const newTasks = generated.tasks.map((t, i) => ({
+            id: `TASK-${String(completedTasks.length + i + 1).padStart(3, '0')}`,
+            title: t.title, description: t.description,
+            status: 'pending',
+            priority: (['high', 'medium', 'low'].includes(t.priority) ? t.priority : 'medium'),
+            module: t.module || 'general',
+        }));
+        await taskEngine.setTasks([...completedTasks, ...newTasks]);
+        spinner.succeed(c.success(`${newTasks.length} tareas generadas`));
+        newTasks.forEach(task => {
+            const pColor = task.priority === 'high' ? c.error : task.priority === 'medium' ? c.warning : c.dim;
+            console.log(`  ${c.dim('○')} ${c.bold(task.id)} ${pColor(`[${task.priority.toUpperCase()}]`)} ${task.title}`);
+        });
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Error');
+        showError(error instanceof Error ? error.message : String(error));
+    }
+}
+// ─── NEXT ───────────────────────────────────────────────────────────
+async function handleNext() {
+    if (!(await requireInit()))
+        return;
+    const contextEngine = new ContextEngine();
+    await contextEngine.load();
+    const state = contextEngine.getState();
+    const taskEngine = new TaskEngine();
+    await taskEngine.load();
+    if (state.current_task_id) {
+        const current = taskEngine.getTaskById(state.current_task_id);
+        if (current && current.status === 'in_progress') {
+            showHeader('Tarea en Progreso');
+            printTaskDetail(current);
+            showInfo('Ve a desarrollar — CCODE detectará los cambios.');
+            return;
+        }
+    }
+    const nextTask = taskEngine.getNextTask();
+    if (!nextTask) {
+        const stats = taskEngine.getStats();
+        if (stats.total === 0) {
+            showWarning('No hay tareas.');
+        }
+        else {
+            showSuccess(`Todas completadas (${stats.completed}/${stats.total})`);
+        }
+        return;
+    }
+    showHeader('Siguiente Tarea');
+    printTaskDetail(nextTask);
+    const { startTask } = await inquirer.prompt([{
+            type: 'confirm', name: 'startTask',
+            message: '¿Iniciar esta tarea?', default: true,
+        }]);
+    if (startTask) {
+        await taskEngine.updateTaskStatus(nextTask.id, 'in_progress');
+        await contextEngine.updateState({ current_task_id: nextTask.id, workflow_stage: 'in_progress' });
+        showSuccess(`${nextTask.id} en progreso.`);
+        showInfo('Abre otra terminal y desarrolla. CCODE vigila los cambios.');
+    }
+}
+function printTaskDetail(task) {
+    const priorityColors = {
+        critical: c.error, high: c.warning, medium: c.primary, low: c.dim,
+    };
+    const pColor = priorityColors[task.priority] || c.white;
+    console.log(`  ${c.bold(task.id)}  ${pColor(`[${task.priority.toUpperCase()}]`)}  ${c.dim(task.module)}`);
+    console.log('');
+    console.log(c.white(`  ${task.title}`));
+    console.log('');
+    console.log(c.dim('  Criterios de aceptación:'));
+    task.description.split('\n').forEach(line => console.log(c.dim(`  ${line}`)));
+    console.log('');
+}
+// ─── VERIFY ─────────────────────────────────────────────────────────
+async function handleVerify() {
+    if (!(await requireInit()))
+        return;
+    const config = await requireAI();
+    if (!config)
+        return;
+    showHeader('Verificando Progreso');
+    const taskEngine = new TaskEngine();
+    await taskEngine.load();
+    const tasks = taskEngine.getTasks();
+    if (tasks.length === 0) {
+        showWarning('No hay tareas.');
+        return;
+    }
+    const spinner = ora({ text: 'Analizando proyecto...', color: 'cyan', spinner: 'dots' }).start();
+    try {
+        const ccodePath = path.join(process.cwd(), '.ccode');
+        const projectMd = await FileUtils.readFileSafe(path.join(ccodePath, 'project.md'));
+        const archMd = await FileUtils.readFileSafe(path.join(ccodePath, 'architecture.md'));
+        const projectFiles = listProjectFiles(process.cwd()).join('\n');
+        const provider = AIManager.getProvider(config);
+        const verifyPrompt = PromptBuilder.getVerificationPrompt(projectMd, archMd, tasks, projectFiles);
+        spinner.text = 'La IA verifica las tareas...';
+        const response = await provider.generate(verifyPrompt);
+        spinner.succeed(c.success('Verificación completada'));
+        try {
+            const result = PromptBuilder.parseJSON(response);
+            console.log('');
+            for (const v of result.verification) {
+                const task = taskEngine.getTaskById(v.task_id);
+                if (!task)
+                    continue;
+                const icon = v.status === 'completed' ? c.success('✓')
+                    : v.status === 'in_progress' ? c.warning('◐')
+                        : v.status === 'blocked' ? c.error('✗') : c.dim('○');
+                console.log(`  ${icon} ${c.bold(v.task_id)} ${task.title}`);
+                console.log(c.dim(`    ${v.evidence}`));
+                if (v.missing)
+                    console.log(c.warning(`    Falta: ${v.missing}`));
+                console.log('');
+            }
+            console.log(c.primary('  ─ Resumen ─'));
+            console.log(c.white(`  ${result.summary}`));
+            if (result.next_recommended) {
+                console.log(c.primary(`\n  → ${result.next_recommended}`));
+            }
+            console.log('');
+            const { updateStates } = await inquirer.prompt([{
+                    type: 'confirm', name: 'updateStates',
+                    message: '¿Actualizar estados según la verificación?', default: true,
+                }]);
+            if (updateStates) {
+                const contextEngine = new ContextEngine();
+                await contextEngine.load();
+                for (const v of result.verification) {
+                    const task = taskEngine.getTaskById(v.task_id);
+                    if (!task)
+                        continue;
+                    if (v.status === 'completed' && task.status !== 'completed') {
+                        await taskEngine.updateTaskStatus(v.task_id, 'completed');
+                        // Registrar en memoria
+                        const memoryPath = path.join(process.cwd(), '.ccode/memory.md');
+                        const entry = `\n### Auto-completada: [${v.task_id}] ${task.title}\n- **Fecha:** ${new Date().toISOString().split('T')[0]}\n- **Verificado por IA:** ${v.evidence}\n`;
+                        const mem = await FileUtils.readFileSafe(memoryPath, '# Memoria\n');
+                        await FileUtils.writeFile(memoryPath, mem + entry);
+                        // Si era la tarea activa, limpiar
+                        if (contextEngine.getState().current_task_id === v.task_id) {
+                            await contextEngine.updateState({ current_task_id: null, workflow_stage: 'idle' });
+                        }
+                        showSuccess(`${v.task_id} marcada como completada automáticamente.`);
+                    }
+                }
+            }
+        }
+        catch {
+            console.log('');
+            response.split('\n').forEach(line => console.log(`  ${line}`));
+            console.log('');
+        }
+    }
+    catch (error) {
+        spinner.fail('Error');
+        showError(error instanceof Error ? error.message : String(error));
+    }
+}
+// ─── COMPLETE ───────────────────────────────────────────────────────
+async function handleComplete() {
+    if (!(await requireInit()))
+        return;
+    const contextEngine = new ContextEngine();
+    await contextEngine.load();
+    const state = contextEngine.getState();
+    const taskEngine = new TaskEngine();
+    await taskEngine.load();
+    let taskToComplete;
+    if (state.current_task_id) {
+        taskToComplete = taskEngine.getTaskById(state.current_task_id);
+    }
+    if (!taskToComplete) {
+        const inProgress = taskEngine.getTasks().filter(t => t.status === 'in_progress');
+        if (inProgress.length === 0) {
+            showWarning('No hay tareas activas.');
+            return;
+        }
+        if (inProgress.length === 1) {
+            taskToComplete = inProgress[0];
+        }
+        else {
+            const { selectedId } = await inquirer.prompt([{
+                    type: 'select', name: 'selectedId',
+                    message: '¿Cuál completar?',
+                    choices: inProgress.map(t => ({ name: `  ${t.id} — ${t.title}`, value: t.id })),
+                }]);
+            taskToComplete = taskEngine.getTaskById(selectedId);
+        }
+    }
+    if (!taskToComplete)
+        return;
+    showHeader('Completar', `${taskToComplete.id} — ${taskToComplete.title}`);
+    console.log(c.dim('  Criterios:'));
+    taskToComplete.description.split('\n').forEach(line => console.log(c.dim(`  ${line}`)));
+    console.log('');
+    const { confirmComplete } = await inquirer.prompt([{
+            type: 'confirm', name: 'confirmComplete',
+            message: '¿Criterios cumplidos?', default: true,
+        }]);
+    if (!confirmComplete) {
+        showInfo('Usa "verificar" para que la IA revise.');
+        return;
+    }
+    await taskEngine.updateTaskStatus(taskToComplete.id, 'completed');
+    await contextEngine.updateState({ current_task_id: null, workflow_stage: 'idle' });
+    const memoryPath = path.join(process.cwd(), '.ccode/memory.md');
+    const entry = `\n### Completada: [${taskToComplete.id}] ${taskToComplete.title}\n- **Fecha:** ${new Date().toISOString().split('T')[0]}\n`;
+    const mem = await FileUtils.readFileSafe(memoryPath, '# Memoria\n');
+    await FileUtils.writeFile(memoryPath, mem + entry);
+    showSuccess(`${taskToComplete.id} completada.`);
+    const stats = taskEngine.getStats();
+    console.log(c.primary(`  ${showProgressBar(stats.completed, stats.total)}`));
+}
+// ─── STATUS ─────────────────────────────────────────────────────────
+async function handleStatus() {
+    if (!(await requireInit()))
+        return;
+    const contextEngine = new ContextEngine();
+    await contextEngine.load();
+    const context = contextEngine.getContext();
+    const state = contextEngine.getState();
+    const taskEngine = new TaskEngine();
+    await taskEngine.load();
+    const stats = taskEngine.getStats();
+    const config = await AIManager.loadConfig();
+    showHeader('Estado', `${context.name} v${context.version}`);
+    if (config)
+        console.log(c.dim(`  IA: ${config.provider} (${config.model || 'default'})`));
+    else
+        console.log(c.warning('  IA: No configurado'));
+    console.log('');
+    if (stats.total > 0) {
+        console.log(c.primary(`  ${showProgressBar(stats.completed, stats.total)}`));
+        console.log('');
+        console.log(c.success(`  ● Completadas:  ${stats.completed}`));
+        if (stats.in_progress > 0)
+            console.log(c.warning(`  ◐ En progreso:  ${stats.in_progress}`));
+        console.log(c.white(`  ○ Pendientes:   ${stats.pending}`));
+        if (stats.failed > 0)
+            console.log(c.error(`  ✗ Fallidas:     ${stats.failed}`));
+        console.log('');
+        taskEngine.getTasks().forEach(task => {
+            const icon = task.status === 'completed' ? c.success('✓')
+                : task.status === 'in_progress' ? c.warning('◐')
+                    : task.status === 'failed' ? c.error('✗') : c.dim('○');
+            const color = task.status === 'completed' ? c.dim : c.white;
+            console.log(`  ${icon} ${c.dim(task.id)} ${color(task.title)}`);
+        });
+    }
+    else {
+        console.log(c.dim('  Sin tareas.'));
+    }
+    console.log('');
+}
+// ─── CONTEXT ────────────────────────────────────────────────────────
+async function handleContext() {
+    if (!(await requireInit()))
+        return;
+    showHeader('Contexto del Proyecto');
+    const { file } = await inquirer.prompt([{
+            type: 'select', name: 'file',
+            message: '¿Qué ver?',
+            choices: [
+                { name: '  📄 Documentación (project.md)', value: 'project.md' },
+                { name: '  🏗  Arquitectura', value: 'architecture.md' },
+                { name: '  📏 Reglas', value: 'rules.md' },
+                { name: '  🧠 Memoria', value: 'memory.md' },
+                { name: '  📝 Prompt original', value: 'user-prompt.md' },
+                { name: '  📋 Contexto completo', value: '__full__' },
+            ],
+        }]);
+    const ccodePath = path.join(process.cwd(), '.ccode');
+    if (file === '__full__') {
+        const pb = new PromptBuilder();
+        const full = await pb.buildContextPrompt();
+        console.log('');
+        full.split('\n').forEach(line => console.log(`  ${line}`));
+    }
+    else {
+        const content = await FileUtils.readFileSafe(path.join(ccodePath, file), '(Vacío)');
+        console.log('');
+        content.split('\n').forEach(line => console.log(`  ${line}`));
+    }
+    console.log('');
+}
+// ─── CLI Setup ──────────────────────────────────────────────────────
+async function main() {
+    const program = new Command();
+    program
+        .name('ccode')
+        .description('CCODE: Contexto Persistente para Desarrollo con IA')
+        .version('2.0.0');
+    // Comandos individuales (para uso rápido sin sesión)
+    program.command('init').description('Inicializa el contexto del proyecto').action(async () => {
+        await handleInit();
+        // Después de init → entrar en sesión
+        await startSession();
+    });
+    program.command('connect').description('Configura el proveedor de IA').action(handleConnect);
+    program.command('plan').description('Genera o regenera tareas').action(handlePlan);
+    program.command('next').description('Siguiente tarea').action(handleNext);
+    program.command('verify').description('Verifica progreso con IA').action(handleVerify);
+    program.command('complete').description('Completa una tarea').action(handleComplete);
+    program.command('status').description('Estado del proyecto').action(handleStatus);
+    program.command('context').description('Ver contexto generado').action(handleContext);
+    if (process.argv.length <= 2) {
+        // Sin argumentos → sesión interactiva
+        const isInitialized = await FileUtils.exists(path.join(process.cwd(), '.ccode'));
+        if (!isInitialized) {
+            showWelcome();
+            showInfo('Este directorio no tiene un proyecto CCODE.');
+            console.log('');
+            const { doInit } = await inquirer.prompt([{
+                    type: 'confirm', name: 'doInit',
+                    message: '¿Inicializar proyecto aquí?', default: true,
+                }]);
+            if (doInit) {
+                await handleInit();
+                await startSession();
+            }
+        }
+        else {
+            showLogo();
+            showSuccess('Proyecto detectado. Iniciando sesión...');
+            await startSession();
+        }
+    }
+    else {
+        await program.parseAsync(process.argv);
+    }
+}
+main().catch((error) => {
+    watcher.stop();
+    showError(`Error: ${error instanceof Error ? error.message : error}`);
+    process.exit(1);
+});