@korl3one/ccode 2.0.0

package/dist/cli/watcher.d.ts

@@ -0,0 +1,31 @@
+/**
+ * FileWatcher: observa cambios en el proyecto en tiempo real.
+ * Acumula cambios entre interacciones del usuario.
+ */
+export declare class FileWatcher {
+    private changes;
+    private watcher;
+    private active;
+    private debounceTimer;
+    private onChangeCallback;
+    private static readonly IGNORE;
+    start(projectDir: string): void;
+    /**
+     * Callback que se ejecuta cuando hay cambios (con debounce).
+     */
+    onChange(callback: (changes: Map<string, string>) => void): void;
+    /**
+     * Obtiene y limpia los cambios acumulados.
+     */
+    flush(): string[];
+    /**
+     * Cantidad de cambios pendientes.
+     */
+    get pendingCount(): number;
+    stop(): void;
+    isActive(): boolean;
+}
+/**
+ * Muestra un resumen de los cambios detectados.
+ */
+export declare function displayChanges(files: string[]): void;

package/dist/cli/watcher.js

@@ -0,0 +1,90 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { c } from './brand.js';
+/**
+ * FileWatcher: observa cambios en el proyecto en tiempo real.
+ * Acumula cambios entre interacciones del usuario.
+ */
+export class FileWatcher {
+    changes = new Map(); // filename → event type
+    watcher = null;
+    active = false;
+    debounceTimer = null;
+    onChangeCallback = null;
+    static IGNORE = [
+        'node_modules', '.ccode', '.git', 'dist', '.next', '__pycache__',
+        '.venv', '.DS_Store', '.env', 'coverage', '.turbo', '.cache',
+    ];
+    start(projectDir) {
+        if (this.active)
+            return;
+        try {
+            this.watcher = fs.watch(projectDir, { recursive: true }, (event, filename) => {
+                if (!filename)
+                    return;
+                // Ignorar directorios y archivos del sistema
+                const parts = filename.split(path.sep);
+                if (parts.some(p => FileWatcher.IGNORE.includes(p) || p.startsWith('.')))
+                    return;
+                this.changes.set(filename, event);
+                // Debounce: esperar 2s de inactividad antes de notificar
+                if (this.debounceTimer)
+                    clearTimeout(this.debounceTimer);
+                this.debounceTimer = setTimeout(() => {
+                    if (this.onChangeCallback && this.changes.size > 0) {
+                        this.onChangeCallback(new Map(this.changes));
+                    }
+                }, 2000);
+            });
+            this.active = true;
+        }
+        catch {
+            // fs.watch puede fallar en algunos sistemas — ignorar silenciosamente
+        }
+    }
+    /**
+     * Callback que se ejecuta cuando hay cambios (con debounce).
+     */
+    onChange(callback) {
+        this.onChangeCallback = callback;
+    }
+    /**
+     * Obtiene y limpia los cambios acumulados.
+     */
+    flush() {
+        const files = [...this.changes.keys()];
+        this.changes.clear();
+        return files;
+    }
+    /**
+     * Cantidad de cambios pendientes.
+     */
+    get pendingCount() {
+        return this.changes.size;
+    }
+    stop() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.watcher?.close();
+        this.watcher = null;
+        this.active = false;
+        this.changes.clear();
+    }
+    isActive() {
+        return this.active;
+    }
+}
+/**
+ * Muestra un resumen de los cambios detectados.
+ */
+export function displayChanges(files) {
+    if (files.length === 0)
+        return;
+    console.log('');
+    console.log(c.accent(`  ⟳ ${files.length} archivo${files.length > 1 ? 's' : ''} modificado${files.length > 1 ? 's' : ''} detectado${files.length > 1 ? 's' : ''}:`));
+    const show = files.slice(0, 8);
+    show.forEach(f => console.log(c.dim(`    ${f}`)));
+    if (files.length > 8)
+        console.log(c.dim(`    ... y ${files.length - 8} más`));
+    console.log('');
+}

package/dist/core/context.d.ts

@@ -0,0 +1,26 @@
+export interface IProjectContext {
+    name: string;
+    version: string;
+    architecture_file: string;
+    rules_file: string;
+    tasks_file: string;
+}
+export type WorkflowStage = 'created' | 'connected' | 'planned' | 'in_progress' | 'idle';
+export interface IProjectState {
+    current_task_id: string | null;
+    workflow_stage: WorkflowStage;
+}
+/**
+ * Motor de Contexto: gestiona el estado persistente del proyecto .ccode/
+ */
+export declare class ContextEngine {
+    private static readonly CCODE_DIR;
+    private context;
+    private state;
+    get ccodePath(): string;
+    load(): Promise<boolean>;
+    getContext(): IProjectContext;
+    getState(): IProjectState;
+    updateState(newState: Partial<IProjectState>): Promise<void>;
+    readContextFile(filename: string): Promise<string>;
+}

package/dist/core/context.js

@@ -0,0 +1,45 @@
+import * as path from 'path';
+import { FileUtils } from '../utils/files.js';
+/**
+ * Motor de Contexto: gestiona el estado persistente del proyecto .ccode/
+ */
+export class ContextEngine {
+    static CCODE_DIR = '.ccode';
+    context = null;
+    state = null;
+    get ccodePath() {
+        return path.join(process.cwd(), ContextEngine.CCODE_DIR);
+    }
+    async load() {
+        if (!(await FileUtils.exists(this.ccodePath))) {
+            return false;
+        }
+        try {
+            this.context = await FileUtils.readJson(path.join(this.ccodePath, 'context.json'));
+            this.state = await FileUtils.readJson(path.join(this.ccodePath, 'state.json'));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getContext() {
+        if (!this.context)
+            throw new Error('Contexto no cargado.');
+        return this.context;
+    }
+    getState() {
+        if (!this.state)
+            throw new Error('Estado no cargado.');
+        return this.state;
+    }
+    async updateState(newState) {
+        if (!this.state)
+            throw new Error('Estado no cargado.');
+        this.state = { ...this.state, ...newState };
+        await FileUtils.writeJson(path.join(this.ccodePath, 'state.json'), this.state);
+    }
+    async readContextFile(filename) {
+        return FileUtils.readFileSafe(path.join(this.ccodePath, filename));
+    }
+}

package/dist/core/prompt-builder.d.ts

@@ -0,0 +1,38 @@
+import { ITask } from './tasks.js';
+/**
+ * PromptBuilder: genera contexto de proyecto, NO código.
+ *
+ * CCODE es una capa de contexto. Su trabajo es:
+ * - Generar documentación, arquitectura, reglas y tareas
+ * - Adaptar la complejidad al tamaño real del proyecto
+ * - Las tareas son un checklist descriptivo, no implementaciones
+ */
+export declare class PromptBuilder {
+    private static readonly CCODE_DIR;
+    /**
+     * Meta-prompt inteligente: adapta la complejidad del contexto al proyecto.
+     * Proyecto simple → contexto ligero. Proyecto complejo → arquitectura detallada.
+     */
+    static getContextGenerationPrompt(name: string, description: string, features: string, techStack: string, projectType: string): string;
+    /**
+     * Prompt para regenerar/refinar tareas basado en el estado actual.
+     */
+    static getPlanRegenerationPrompt(projectMd: string, archMd: string, rulesMd: string, currentTasks: ITask[], extraContext: string): string;
+    /**
+     * Prompt para verificar el estado de las tareas (qué se cumplió y qué falta).
+     */
+    static getVerificationPrompt(projectMd: string, archMd: string, tasks: ITask[], projectFiles: string): string;
+    /**
+     * Extrae JSON de la respuesta de la IA.
+     */
+    static parseJSON<T>(response: string): T;
+    /**
+     * Genera el prompt de contexto completo del proyecto.
+     * Este es el contexto que cualquier IA puede leer para entender el proyecto.
+     */
+    buildContextPrompt(): Promise<string>;
+    /**
+     * Genera prompt enfocado en una tarea específica.
+     */
+    buildTaskPrompt(taskId: string | null): Promise<string>;
+}

package/dist/core/prompt-builder.js

@@ -0,0 +1,250 @@
+import * as path from 'path';
+import { TaskEngine } from './tasks.js';
+import { FileUtils } from '../utils/files.js';
+/**
+ * PromptBuilder: genera contexto de proyecto, NO código.
+ *
+ * CCODE es una capa de contexto. Su trabajo es:
+ * - Generar documentación, arquitectura, reglas y tareas
+ * - Adaptar la complejidad al tamaño real del proyecto
+ * - Las tareas son un checklist descriptivo, no implementaciones
+ */
+export class PromptBuilder {
+    static CCODE_DIR = '.ccode';
+    /**
+     * Meta-prompt inteligente: adapta la complejidad del contexto al proyecto.
+     * Proyecto simple → contexto ligero. Proyecto complejo → arquitectura detallada.
+     */
+    static getContextGenerationPrompt(name, description, features, techStack, projectType) {
+        return `Eres un arquitecto de software senior. Tu trabajo es generar el CONTEXTO DE TRABAJO para un proyecto, NO código.
+
+IMPORTANTE — ADAPTA LA COMPLEJIDAD:
+- Si el proyecto es simple (pocas funcionalidades, stack básico, prototipo o prueba), genera contexto LIGERO: documentación breve, arquitectura mínima, pocas reglas, 3-5 tareas.
+- Si el proyecto es mediano, genera contexto MODERADO: documentación clara, arquitectura con estructura de carpetas, reglas prácticas, 5-8 tareas.
+- Si el proyecto es complejo (múltiples módulos, integraciones, escalabilidad), genera contexto COMPLETO: documentación detallada, arquitectura con diagramas, patrones, reglas exhaustivas, 8-12 tareas.
+
+Analiza la descripción y decide el nivel de complejidad automáticamente. NO sobre-documentes un proyecto simple.
+
+=== PROYECTO ===
+NOMBRE: ${name}
+DESCRIPCIÓN: ${description}
+FUNCIONALIDADES: ${features}
+STACK: ${techStack}
+TIPO: ${projectType}
+
+Responde ÚNICAMENTE con JSON válido. Sin bloques de código markdown, sin texto antes ni después:
+
+{
+  "project_name": "nombre del proyecto",
+  "complexity": "simple|medium|complex",
+  "project": "Contenido Markdown para project.md. Visión, objetivos, alcance y funcionalidades. Proporcionado al nivel de detalle que el proyecto necesita.",
+  "architecture": "Contenido Markdown para architecture.md. Estructura del proyecto, tecnologías y sus roles, estructura de carpetas. Solo incluye diagramas y patrones si la complejidad lo justifica.",
+  "rules": "Contenido Markdown para rules.md. Convenciones de código y estándares adaptados al stack. Breve para proyectos simples, detallado para complejos.",
+  "tasks": [
+    {
+      "title": "Descripción clara de QUÉ hacer (no CÓMO implementarlo)",
+      "description": "Criterios de aceptación: qué debe cumplirse para considerar esta tarea completa",
+      "priority": "high",
+      "module": "fase o área"
+    }
+  ]
+}
+
+REGLAS PARA LAS TAREAS:
+- Las tareas son un CHECKLIST de trabajo, NO instrucciones de código
+- Cada tarea describe QUÉ lograr, no CÓMO programarlo
+- La descripción debe tener criterios de aceptación claros
+- Ordénalas por dependencia lógica (qué va primero)
+- Cada tarea debe ser verificable: se puede confirmar si está hecha o no
+- Ejemplo bueno: "Crear formulario de login con campos usuario y contraseña"
+- Ejemplo malo: "Implementar const form = document.createElement('form')..."
+
+REGLAS GENERALES:
+- Todo en español
+- Contenido específico al stack indicado (no genérico)
+- priority: "high", "medium" o "low"
+- NO generes código en ningún campo
+- NO uses backticks de markdown alrededor del JSON`;
+    }
+    /**
+     * Prompt para regenerar/refinar tareas basado en el estado actual.
+     */
+    static getPlanRegenerationPrompt(projectMd, archMd, rulesMd, currentTasks, extraContext) {
+        const completedTasks = currentTasks.filter(t => t.status === 'completed');
+        const pendingTasks = currentTasks.filter(t => t.status === 'pending' || t.status === 'in_progress');
+        const failedTasks = currentTasks.filter(t => t.status === 'failed');
+        const completedInfo = completedTasks.length > 0
+            ? completedTasks.map(t => `- ✓ ${t.id}: ${t.title}`).join('\n')
+            : 'Ninguna completada aún.';
+        const pendingInfo = pendingTasks.length > 0
+            ? pendingTasks.map(t => `- ○ ${t.id}: ${t.title} [${t.priority}]`).join('\n')
+            : 'Ninguna pendiente.';
+        const failedInfo = failedTasks.length > 0
+            ? failedTasks.map(t => `- ✗ ${t.id}: ${t.title}`).join('\n')
+            : '';
+        return `Eres un gestor de proyecto. Analiza el estado actual y genera las SIGUIENTES tareas necesarias.
+
+IMPORTANTE: Solo generas un checklist de tareas. NO generas código. Las tareas describen QUÉ hacer, no CÓMO programarlo.
+
+=== PROYECTO ===
+${projectMd}
+
+=== ARQUITECTURA ===
+${archMd}
+
+=== REGLAS ===
+${rulesMd}
+
+=== TAREAS COMPLETADAS ===
+${completedInfo}
+
+=== TAREAS PENDIENTES ACTUALES ===
+${pendingInfo}
+
+${failedInfo ? `=== TAREAS FALLIDAS (necesitan replantearse) ===\n${failedInfo}\n` : ''}
+=== CONTEXTO ADICIONAL DEL USUARIO ===
+${extraContext || 'Ninguno.'}
+
+Genera las próximas tareas. Responde ÚNICAMENTE con JSON válido:
+
+{
+  "tasks": [
+    {
+      "title": "Qué lograr (verificable)",
+      "description": "Criterios de aceptación claros",
+      "priority": "high|medium|low",
+      "module": "fase o área"
+    }
+  ]
+}
+
+- Considera lo ya completado para no repetir trabajo
+- Las tareas fallidas pueden necesitar un enfoque diferente
+- Ordena por dependencia lógica
+- Cada tarea es verificable: se puede confirmar si está hecha o no
+- NO incluyas instrucciones de código en las descripciones`;
+    }
+    /**
+     * Prompt para verificar el estado de las tareas (qué se cumplió y qué falta).
+     */
+    static getVerificationPrompt(projectMd, archMd, tasks, projectFiles) {
+        const taskList = tasks.map(t => `- [${t.status === 'completed' ? '✓' : t.status === 'in_progress' ? '◐' : '○'}] ${t.id}: ${t.title}\n  Criterios: ${t.description}`).join('\n');
+        return `Eres un revisor de proyecto. Tu trabajo es verificar el estado real de las tareas comparando los criterios de aceptación con el estado actual del proyecto.
+
+=== PROYECTO ===
+${projectMd}
+
+=== ARQUITECTURA ESPERADA ===
+${archMd}
+
+=== TAREAS Y SUS CRITERIOS ===
+${taskList}
+
+=== ARCHIVOS EXISTENTES EN EL PROYECTO ===
+${projectFiles}
+
+Analiza y responde ÚNICAMENTE con JSON válido:
+
+{
+  "verification": [
+    {
+      "task_id": "TASK-001",
+      "status": "completed|in_progress|pending|blocked",
+      "evidence": "Qué encontraste que confirma o niega el cumplimiento",
+      "missing": "Qué falta para considerar la tarea completa (null si está completa)"
+    }
+  ],
+  "summary": "Resumen general del progreso del proyecto",
+  "next_recommended": "TASK-XXX - qué tarea debería abordarse siguiente y por qué"
+}`;
+    }
+    /**
+     * Extrae JSON de la respuesta de la IA.
+     */
+    static parseJSON(response) {
+        try {
+            return JSON.parse(response);
+        }
+        catch { /* intentar extraer */ }
+        const start = response.indexOf('{');
+        const end = response.lastIndexOf('}');
+        if (start !== -1 && end !== -1 && end > start) {
+            try {
+                return JSON.parse(response.substring(start, end + 1));
+            }
+            catch { /* intentar con regex */ }
+        }
+        const jsonBlock = response.match(/```(?:json)?\s*([\s\S]*?)```/);
+        if (jsonBlock?.[1]) {
+            try {
+                return JSON.parse(jsonBlock[1].trim());
+            }
+            catch { /* falló todo */ }
+        }
+        throw new Error('No se pudo extraer JSON válido de la respuesta de la IA.');
+    }
+    /**
+     * Genera el prompt de contexto completo del proyecto.
+     * Este es el contexto que cualquier IA puede leer para entender el proyecto.
+     */
+    async buildContextPrompt() {
+        const ccodePath = path.join(process.cwd(), PromptBuilder.CCODE_DIR);
+        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 memoryMd = await FileUtils.readFileSafe(path.join(ccodePath, 'memory.md'));
+        const taskEngine = new TaskEngine();
+        await taskEngine.load();
+        const tasks = taskEngine.getTasks();
+        const stats = taskEngine.getStats();
+        const taskList = tasks.map(t => {
+            const icon = t.status === 'completed' ? '✓' : t.status === 'in_progress' ? '◐' : '○';
+            return `[${icon}] ${t.id} [${t.priority}] ${t.title} — ${t.status}`;
+        }).join('\n');
+        return `
+=== CONTEXTO DEL PROYECTO ===
+${projectMd}
+
+=== ARQUITECTURA ===
+${archMd}
+
+=== REGLAS Y ESTÁNDARES ===
+${rulesMd}
+
+=== PROGRESO DE TAREAS (${stats.completed}/${stats.total} completadas) ===
+${taskList}
+
+=== MEMORIA DE DECISIONES ===
+${memoryMd}
+
+=== NOTA ===
+Este contexto fue generado por CCODE. Úsalo como referencia para mantener
+coherencia arquitectónica y seguir las reglas del proyecto.
+`.trim();
+    }
+    /**
+     * Genera prompt enfocado en una tarea específica.
+     */
+    async buildTaskPrompt(taskId) {
+        const baseContext = await this.buildContextPrompt();
+        let taskFocus = 'No hay una tarea activa seleccionada.';
+        if (taskId) {
+            const taskEngine = new TaskEngine();
+            await taskEngine.load();
+            const task = taskEngine.getTaskById(taskId);
+            if (task) {
+                taskFocus = [
+                    `TAREA ACTIVA: [${task.id}] ${task.title}`,
+                    `Criterios de aceptación: ${task.description}`,
+                    `Prioridad: ${task.priority}`,
+                    `Módulo: ${task.module}`,
+                ].join('\n');
+            }
+        }
+        return `${baseContext}
+
+=== TAREA EN FOCO ===
+${taskFocus}
+`.trim();
+    }
+}

package/dist/core/tasks.d.ts

@@ -0,0 +1,35 @@
+export type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
+export type TaskPriority = 'low' | 'medium' | 'high' | 'critical';
+export interface ITask {
+    id: string;
+    title: string;
+    description: string;
+    status: TaskStatus;
+    priority: TaskPriority;
+    module: string;
+}
+export interface ITasksFile {
+    tasks: ITask[];
+}
+/**
+ * Gestor de Tareas: manipula el flujo de trabajo en .ccode/tasks.json
+ */
+export declare class TaskEngine {
+    private static readonly TASKS_FILE;
+    private tasksData;
+    load(): Promise<void>;
+    save(): Promise<void>;
+    getTasks(): ITask[];
+    getTaskById(id: string): ITask | undefined;
+    addTask(task: Omit<ITask, 'id'>): Promise<string>;
+    setTasks(tasks: ITask[]): Promise<void>;
+    updateTaskStatus(id: string, status: TaskStatus): Promise<void>;
+    getNextTask(): ITask | null;
+    getStats(): {
+        total: number;
+        completed: number;
+        in_progress: number;
+        pending: number;
+        failed: number;
+    };
+}

package/dist/core/tasks.js

@@ -0,0 +1,59 @@
+import * as path from 'path';
+import { FileUtils } from '../utils/files.js';
+/**
+ * Gestor de Tareas: manipula el flujo de trabajo en .ccode/tasks.json
+ */
+export class TaskEngine {
+    static TASKS_FILE = '.ccode/tasks.json';
+    tasksData = { tasks: [] };
+    async load() {
+        const tasksPath = path.join(process.cwd(), TaskEngine.TASKS_FILE);
+        if (await FileUtils.exists(tasksPath)) {
+            this.tasksData = await FileUtils.readJson(tasksPath);
+        }
+    }
+    async save() {
+        const tasksPath = path.join(process.cwd(), TaskEngine.TASKS_FILE);
+        await FileUtils.writeJson(tasksPath, this.tasksData);
+    }
+    getTasks() {
+        return this.tasksData.tasks;
+    }
+    getTaskById(id) {
+        return this.tasksData.tasks.find(t => t.id === id);
+    }
+    async addTask(task) {
+        const id = `TASK-${String(this.tasksData.tasks.length + 1).padStart(3, '0')}`;
+        this.tasksData.tasks.push({ id, ...task });
+        await this.save();
+        return id;
+    }
+    async setTasks(tasks) {
+        this.tasksData.tasks = tasks;
+        await this.save();
+    }
+    async updateTaskStatus(id, status) {
+        const task = this.tasksData.tasks.find(t => t.id === id);
+        if (!task)
+            throw new Error(`Tarea ${id} no encontrada.`);
+        task.status = status;
+        await this.save();
+    }
+    getNextTask() {
+        const pending = this.tasksData.tasks.filter(t => t.status === 'pending');
+        if (pending.length === 0)
+            return null;
+        const priorities = { critical: 4, high: 3, medium: 2, low: 1 };
+        return pending.sort((a, b) => priorities[b.priority] - priorities[a.priority])[0];
+    }
+    getStats() {
+        const tasks = this.tasksData.tasks;
+        return {
+            total: tasks.length,
+            completed: tasks.filter(t => t.status === 'completed').length,
+            in_progress: tasks.filter(t => t.status === 'in_progress').length,
+            pending: tasks.filter(t => t.status === 'pending').length,
+            failed: tasks.filter(t => t.status === 'failed').length,
+        };
+    }
+}

package/dist/utils/files.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Capa de abstracción para operaciones de sistema de archivos.
+ */
+export declare class FileUtils {
+    static ensureDir(dirPath: string): Promise<void>;
+    static writeJson(filePath: string, data: unknown): Promise<void>;
+    static writeFile(filePath: string, content: string): Promise<void>;
+    static readFile(filePath: string): Promise<string>;
+    static readJson<T = unknown>(filePath: string): Promise<T>;
+    static exists(itemPath: string): Promise<boolean>;
+    static readFileSafe(filePath: string, fallback?: string): Promise<string>;
+}

package/dist/utils/files.js

@@ -0,0 +1,34 @@
+import fsExtra from 'fs-extra';
+const fs = fsExtra;
+/**
+ * Capa de abstracción para operaciones de sistema de archivos.
+ */
+export class FileUtils {
+    static async ensureDir(dirPath) {
+        await fs.ensureDir(dirPath);
+    }
+    static async writeJson(filePath, data) {
+        await fs.writeJson(filePath, data, { spaces: 2 });
+    }
+    static async writeFile(filePath, content) {
+        await fs.writeFile(filePath, content, 'utf-8');
+    }
+    static async readFile(filePath) {
+        return await fs.readFile(filePath, 'utf-8');
+    }
+    static async readJson(filePath) {
+        return await fs.readJson(filePath);
+    }
+    static async exists(itemPath) {
+        return await fs.pathExists(itemPath);
+    }
+    static async readFileSafe(filePath, fallback = '') {
+        try {
+            if (await fs.pathExists(filePath)) {
+                return await fs.readFile(filePath, 'utf-8');
+            }
+        }
+        catch { /* ignore */ }
+        return fallback;
+    }
+}