npm - @korl3one/ccode - Versions diffs - 2.0.1 → 2.2.0 - Mend

@korl3one/ccode 2.0.1 → 2.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/README.md CHANGED Viewed

@@ -5,328 +5,242 @@
   ██║     ██║      ██║   ██║██║  ██║██╔══╝
   ╚██████╗╚██████╗ ╚██████╔╝██████╔╝███████╗
    ╚═════╝ ╚═════╝  ╚═════╝ ╚═════╝ ╚══════╝
-  Context-Persistent AI Development  v2.0
 ```
----
-# CCODE — Contexto Persistente para Desarrollo Asistido
-## QUE es CCODE
-CCODE es una herramienta CLI que genera y mantiene el **contexto de trabajo** de un proyecto de software. Genera documentacion profesional, arquitectura, reglas de desarrollo y un checklist de tareas verificables — todo adaptado automaticamente a la complejidad real del proyecto.
-**CCODE no genera codigo.** Genera el contexto que guia el desarrollo.
-Cuando ejecutas `ccode init`, un wizard interactivo te pregunta sobre tu proyecto y una IA genera:
-| Archivo | Contenido |
-|---------|-----------|
-| `project.md` | Vision, objetivos, alcance y funcionalidades |
-| `architecture.md` | Estructura del sistema adaptada a la complejidad |
-| `rules.md` | Estandares de desarrollo especificos al stack |
-| `tasks.json` | Checklist de tareas con criterios de aceptacion |
-| `state.json` | Tarea activa y etapa del workflow |
-| `context.json` | Configuracion general del proyecto |
-| `memory.md` | Historial de decisiones y tareas completadas |
-| `config.json` | Configuracion del proveedor de IA |
-Todo vive en la carpeta `.ccode/` dentro del repositorio. Cualquier desarrollador o IA puede leerla y entender el proyecto al instante.
+# CCODE
-### El principio fundamental
+**Persistent context CLI for AI-assisted development.**
-> **El contexto vive en el proyecto, no en la conversacion.**
-Cuando trabajas con IA en un proyecto grande, el contexto se pierde al cambiar de sesion, modelo o herramienta. Cada vez hay que re-explicar todo. CCODE resuelve esto almacenando el contexto en el repositorio como archivos versionables con Git.
----
-## COMO funciona
-### Instalacion
+Stop re-explaining your project to AI every time the session resets.
 ```bash
 npm install -g @korl3one/ccode
+ccode init
 ```
-Eso es todo. Ya puedes usar `ccode` en cualquier proyecto.
-### Contribuir al desarrollo
-Si quieres colaborar con el proyecto:
+[![npm version](https://img.shields.io/npm/v/@korl3one/ccode)](https://www.npmjs.com/package/@korl3one/ccode)
+[![license](https://img.shields.io/npm/l/@korl3one/ccode)](LICENSE)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](https://nodejs.org)
-```bash
-git clone https://github.com/iDevelop25/ccode.git
-cd ccode
-npm install
-npm run build
-npm link
-```
+---
-### Flujo de trabajo
+## The problem
-#### Paso 1: Inicializar el proyecto
+Every time you switch sessions, models, or tools when working with AI, you lose your project context. You end up re-explaining the architecture, previous decisions, and current state over and over again.
-```bash
-cd mi-proyecto
-ccode init
-```
+## The solution
-El wizard te guia paso a paso:
+CCODE stores your project context **inside the repository**. One command generates professional documentation, architecture, rules, and a verifiable task checklist — all adapted to your project's actual complexity.
-```
-●○○○  Paso 1/4 — Descripcion del proyecto
-  > "Una app de gestion de tareas con autenticacion y dashboard"
+Any developer or AI can read `.ccode/` and understand the project instantly.
-●●○○  Paso 2/4 — Funcionalidades principales
-  > "Login, registro, CRUD de tareas, filtros, estadisticas"
+---
-●●●○  Paso 3/4 — Stack tecnologico
-  > "Next.js, TypeScript, Prisma, PostgreSQL"
+## Demo
-●●●●  Paso 4/4 — Tipo de proyecto
-  > "Aplicacion web"
 ```
+$ ccode init
-La IA analiza la descripcion y decide automaticamente el nivel de complejidad:
+   ██████╗ ██████╗  ██████╗ ██████╗ ███████╗
+  ██╔════╝██╔════╝ ██╔═══██╗██╔══██╗██╔════╝
+  ██║     ██║      ██║   ██║██║  ██║█████╗
+  ╚██████╗╚██████╗ ╚██████╔╝██████╔╝███████╗
+   ╚═════╝ ╚═════╝  ╚═════╝ ╚═════╝ ╚══════╝
-- **Simple** (prototipo, pocas features): contexto ligero, 3-5 tareas
-- **Medio** (app estandar): contexto moderado, 5-8 tareas
-- **Complejo** (multiples modulos, integraciones): contexto completo con patrones y diagramas, 8-12 tareas
+  ●●●●  Paso 4/4
-Un login simple no necesita diagramas de microservicios. CCODE es inteligente al respecto.
+  ✓ Contexto generado exitosamente
-#### Paso 2: Sesion persistente
+  .ccode/
+  ├── project.md        Documentacion del proyecto
+  ├── architecture.md   Arquitectura del sistema
+  ├── rules.md          Estandares de desarrollo
+  ├── tasks.json        Checklist de tareas (8 tareas)
+  ├── context.json      Configuracion
+  ├── state.json        Estado del workflow
+  └── memory.md         Historial de decisiones
-Despues de `init`, CCODE **no se cierra**. Entra en una sesion interactiva que se queda activa observando tu proyecto:
+  CCODE sigue observando tu proyecto...
-```
   ████████████░░░░░░░░  60%  (3/5)
   > Tarea activa: TASK-002 — Crear formulario de login
   ? Que hacemos?
     > Verificar progreso (se detectaron cambios)
       Marcar tarea como completada
-      Iniciar siguiente tarea (2 pendientes)
-      Generar / actualizar plan de tareas
+      Iniciar siguiente tarea
       Ver estado completo
-      Ver contexto generado
       Salir
 ```
-La sesion funciona como un loop continuo:
+---
+## Why CCODE?
-1. **Detecta cambios** en tus archivos automaticamente (FileWatcher)
-2. **Muestra progreso** con barra visual y tarea activa
-3. **Adapta el menu** al estado actual del proyecto
-4. **Sugiere acciones** relevantes (si hay cambios + tarea activa → sugiere verificar)
-5. **Se recupera de errores** — si algo falla, la sesion sigue activa
+| | CCODE | Manual prompts |
+|---|:---:|:---:|
+| Persistent project context | ✅ | ❌ |
+| Architecture adapted to complexity | ✅ | ❌ |
+| AI-ready documentation | ✅ | ❌ |
+| Verifiable task checklist | ✅ | ❌ |
+| Auto-detect file changes | ✅ | ❌ |
+| AI-powered task verification | ✅ | ❌ |
+| Works with 6 AI providers | ✅ | ❌ |
+| Context lives in the repo (Git) | ✅ | ❌ |
-Tu desarrollas en tu editor favorito. CCODE esta en otra terminal como un acompanante que detecta tu progreso.
+---
-#### Paso 3: Verificacion automatica
+## How it works
-Cuando CCODE detecta cambios en tus archivos, puedes pedirle que verifique:
+### 1. Initialize
+```bash
+cd my-project
+ccode init
 ```
-  > Verificar progreso con IA
-  Verificando 5 tareas contra el estado del proyecto...
+A step-by-step wizard asks about your project and an AI generates the full context. CCODE adapts automatically:
-  ✓ TASK-001: Configurar proyecto base — COMPLETADA
-    Evidencia: package.json, tsconfig.json y estructura de carpetas encontrados
+- **Simple project** (prototype, few features) → lightweight context, 3-5 tasks
+- **Medium project** (standard app) → moderate context, 5-8 tasks
+- **Complex project** (multiple modules, integrations) → detailed architecture, 8-12 tasks
-  ◐ TASK-002: Crear formulario de login — EN PROGRESO
-    Falta: Campo de contrasena no encontrado, validacion pendiente
+### 2. Persistent session
-  ○ TASK-003: Implementar autenticacion JWT — PENDIENTE
-```
+After init, CCODE stays active — watching your project in real time:
-La IA compara los **criterios de aceptacion** de cada tarea con los **archivos reales** del proyecto. No adivina — verifica.
+- Detects file changes automatically
+- Suggests verifying tasks when it sees progress
+- Adapts the menu to your current workflow state
+- Recovers from errors without crashing
-#### Acciones disponibles
+You code in your editor. CCODE runs in another terminal as a companion.
-| Accion | Que hace |
-|--------|----------|
-| **Conectar IA** | Configura Claude o Ollama como proveedor |
-| **Siguiente tarea** | Muestra la tarea mas prioritaria y ofrece iniciarla |
-| **Verificar progreso** | La IA escanea el proyecto y actualiza estados |
-| **Completar tarea** | Marca como completada, registra en memoria |
-| **Re-planificar** | Genera nuevas tareas considerando lo ya completado |
-| **Ver estado** | Dashboard con barra de progreso y estadisticas |
-| **Ver contexto** | Muestra cualquier archivo de `.ccode/` |
+### 3. AI verification
----
+CCODE compares **acceptance criteria** against **actual project files**:
-## POR QUE CCODE
+```
+✓ TASK-001: Setup project base — COMPLETED
+  Evidence: package.json, tsconfig.json found
-### El problema
+◐ TASK-002: Create login form — IN PROGRESS
+  Missing: password field not found, validation pending
-El desarrollo asistido por IA tiene un problema critico: **el contexto es efimero**. Cada vez que cambias de sesion, modelo o herramienta, pierdes el contexto acumulado. El desarrollador termina re-explicando la arquitectura, las decisiones previas y el estado actual una y otra vez.
+○ TASK-003: Implement JWT auth — PENDING
+```
-### La solucion
+### 4. Context export
-CCODE aplica el principio de **contexto persistente**: toda la informacion del proyecto se almacena como archivos dentro del repositorio. Esto significa:
+```bash
+ccode export
+```
-- **Independencia de sesion:** El contexto no depende de la memoria de ninguna herramienta. Cierras CCODE, vuelves manana, y todo sigue ahi.
-- **Independencia de modelo:** Cualquier IA (Claude, GPT, Ollama, la que sea) puede leer `.ccode/` y entender el proyecto al instante.
-- **Trazabilidad:** Cada cambio queda en archivos versionables con Git. Puedes ver cuando se tomo cada decision.
-- **Consistencia:** Todos los colaboradores y herramientas operan con la misma fuente de verdad.
-- **Workflow explicito:** El estado del workflow evita que se ejecuten acciones fuera de orden.
+Generates a single `.md` file with your full project context — ready to paste into any AI chat (ChatGPT, Claude, Gemini, etc.) without connecting an API.
-### Por que contexto y no codigo
+### 5. Project health check
-CCODE genera **que** construir, no **como** programarlo. Las tareas son un checklist descriptivo con criterios de aceptacion:
+```bash
+ccode doctor
+```
 ```
-Bueno:  "Crear formulario de login con campos usuario y contrasena"
-Malo:   "Implementar const form = document.createElement('form')..."
+✓ Contexto generado
+✓ Proveedor de IA configurado
+⚠ 2 tareas sin completar
+⚠ architecture.md no refleja 3 archivos nuevos
+✓ Conexion con IA activa
 ```
-Esto permite que cualquier desarrollador (humano o IA) ejecute las tareas con su propio criterio tecnico. CCODE guia el rumbo, no dicta la implementacion.
 ---
-## PARA QUE sirve CCODE
+## Supported AI Providers
+| Provider | Models | Note |
+|----------|--------|------|
+| **Claude** (Anthropic) | Sonnet 4, Haiku 3.5, Opus 4 | Recommended |
+| **OpenAI** (ChatGPT) | GPT-4o, GPT-4o mini, GPT-4.1, o3-mini | Most popular |
+| **Google Gemini** | 2.5 Flash, 2.5 Pro, 2.0 Flash | Free tier available |
+| **DeepSeek** | Chat, Reasoner | Budget-friendly |
+| **Groq** | Llama 3.3 70B, Llama 3.1 8B, Mixtral 8x7B | Ultra-fast, free tier |
+| **Ollama** | Any local model | Offline, no API key |
-### Para el desarrollador
+---
-- **Elimina la perdida de contexto** entre sesiones de trabajo
-- **Guia paso a paso** sin que te pierdas en un proyecto grande
-- **Detecta tu progreso** automaticamente mientras programas
-- **Adapta la complejidad** al tamano real del proyecto
+## Available commands
-### Para el equipo
+| Command | What it does |
+|---------|-------------|
+| `ccode init` | Interactive wizard — generates full project context |
+| `ccode update` | Re-analyze project and refresh context |
+| `ccode export` | Export context as a single `.md` file for any AI |
+| `ccode explain` | Quick project summary for onboarding |
+| `ccode doctor` | Health check — what's good, what's missing |
+| `ccode connect` | Configure AI provider |
+| `ccode status` | Dashboard with progress bar and stats |
-- **Fuente de verdad unica:** Todos ven el mismo estado del proyecto
-- **Onboarding rapido:** Un nuevo miembro lee `.ccode/` y entiende todo
-- **Decisiones trazables:** El historial de memoria muestra por que se tomaron decisiones
+---
-### Para la IA
+## What gets generated
-- **Contexto completo en un directorio:** Cualquier LLM puede leer `.ccode/` sin configuracion
-- **Tareas verificables:** La IA puede confirmar objetivamente si una tarea esta completa
-- **Arquitectura como referencia:** Las respuestas de la IA mantienen coherencia con la arquitectura definida
+Everything lives in `.ccode/` inside your repository:
+| File | Content |
+|------|---------|
+| `project.md` | Vision, objectives, scope |
+| `architecture.md` | System structure adapted to complexity |
+| `rules.md` | Development standards for your stack |
+| `tasks.json` | Task checklist with acceptance criteria |
+| `state.json` | Active task, workflow stage |
+| `memory.md` | Decision history |
+| `config.json` | AI provider config |
 ---
-## Arquitectura del sistema
+## Architecture
 ```
 src/
-  cli/
-    index.ts          → Entry point, sesion persistente, handlers de acciones
-    brand.ts          → Identidad visual (logo ASCII, paleta, componentes UI)
-    watcher.ts        → FileWatcher (observa cambios en tiempo real)
-  core/
-    context.ts        → ContextEngine (configuracion + estado del workflow)
-    tasks.ts          → TaskEngine (checklist de tareas con prioridades)
-    prompt-builder.ts → Meta-prompts adaptativos, generacion y verificacion
-  ai/
-    provider.ts       → Interfaz comun IAIProvider (patron Adapter)
-    claude.ts         → Adapter para Claude (API de Anthropic)
-    ollama.ts         → Adapter para Ollama (modelos locales)
-    manager.ts        → Gestion de configuracion y conexion
-  utils/
-    files.ts          → Abstraccion del sistema de archivos
+  cli/          → Session, branding, file watcher
+  core/         → Context engine, tasks, prompt builder
+  ai/           → 6 provider adapters (Adapter pattern)
+  utils/        → File system abstraction
 ```
-### Patrones de diseno
-| Patron | Donde | Por que |
-|--------|-------|---------|
-| **Adapter** | `ai/` | Proveedores intercambiables sin cambiar el core |
-| **State Machine** | `context.ts` | Workflow explicito (created → connected → planned → in_progress → idle) |
-| **Observer** | `watcher.ts` | Deteccion reactiva de cambios en archivos |
-| **Builder** | `prompt-builder.ts` | Construccion incremental de prompts complejos |
-### Paleta de colores
-| Color | Hex | Uso |
-|-------|-----|-----|
-| Primary | `#00B4D8` | Elementos principales, headers |
-| Secondary | `#0077B6` | Acentos secundarios |
-| Accent | `#90E0EF` | Highlights, info destacada |
-| Success | `#2DC653` | Operaciones exitosas |
-| Warning | `#FFB703` | Advertencias |
-| Error | `#E63946` | Errores |
-### Logo gradiente
-El logo ASCII usa un gradiente de 6 tonos de azul/cyan:
-`#90E0EF → #48CAE4 → #00B4D8 → #0096C7 → #0077B6 → #023E8A`
+Key patterns: **Adapter** (AI providers), **Observer** (file watcher), **State Machine** (workflow), **Builder** (prompts).
 ---
-## Stack tecnologico
-| Tecnologia | Rol |
-|------------|-----|
-| **Node.js** | Runtime |
-| **TypeScript** | Tipado estatico, interfaces |
-| **ESM** | Sistema de modulos (`"type": "module"`, `NodeNext`) |
-| **Commander.js** | Definicion de comandos CLI |
-| **Inquirer v13** | Prompts interactivos y menus |
-| **Chalk v5** | Colores en terminal |
-| **Ora v8** | Spinners de progreso |
-| **Axios** | HTTP client para APIs de IA |
-| **fs-extra** | Operaciones de archivos mejoradas |
-| **Vitest** | Testing |
+## Contributing
----
+See [CONTRIBUTING.md](CONTRIBUTING.md) for setup instructions and guidelines.
-## Testing
-```bash
-# Ejecutar tests
-npm test
-# Tests en modo watch
-npm test:watch
-```
-19 tests cubriendo:
-- `PromptBuilder.parseJSON` — parsing robusto de respuestas de IA (directo, envuelto en texto, bloques markdown)
-- `TaskEngine` — CRUD de tareas, priorizacion, estadisticas, manejo de errores
-- `FileWatcher` — Estado inicial, flush, stop seguro
+Adding a new AI provider? Just implement `IAIProvider`, add it to the manager switch, done.
 ---
-## Scripts disponibles
+## Learn more
-```bash
-npm run build      # Compilar TypeScript
-npm run dev        # Compilar en modo watch
-npm start          # Ejecutar CCODE
-npm test           # Ejecutar tests
-npm run test:watch # Tests en modo watch
-```
+- [Learning guide](docs/learning/README.md) — 6 modules following QP2C methodology
+- [AGENTS.md](AGENTS.md) — Engineering roles
+- [SKILLS.md](SKILLS.md) — Technical competencies
+- [YouTube @CreativeCode25](https://www.youtube.com/@CreativeCode25) — Tutorials and walkthroughs
 ---
-## Documentacion extendida
-El proyecto incluye una guia de aprendizaje modular bajo la metodologia **QP2C** (Que, Como, Por que, Para que):
+## Support the project
-| Modulo | Tema |
-|--------|------|
-| [00 — Introduccion](docs/learning/modules/00-intro.md) | Que es CCODE y que problema resuelve |
-| [01 — CLI y Sesion](docs/learning/modules/01-cli-session.md) | Arquitectura CLI, loop persistente, menu contextual |
-| [02 — Contexto Persistente](docs/learning/modules/02-context-persistence.md) | ContextEngine, TaskEngine, estado en `.ccode/` |
-| [03 — Generacion de Contexto](docs/learning/modules/03-context-generation.md) | PromptBuilder, meta-prompts, adaptacion de complejidad |
-| [04 — Proveedores de IA](docs/learning/modules/04-ai-providers.md) | Patron Adapter, Claude, Ollama, AIManager |
-| [05 — Watcher y Verificacion](docs/learning/modules/05-watcher-verify.md) | FileWatcher, verificacion automatica de tareas |
+If CCODE helps you, consider giving it a **star on GitHub** ⭐
+It helps the project grow and reach more developers.
-Documentos adicionales:
-- [`AGENTS.md`](AGENTS.md) — Roles de ingenieria del proyecto
-- [`SKILLS.md`](SKILLS.md) — Competencias tecnicas requeridas
+[![GitHub stars](https://img.shields.io/github/stars/iDevelop25/ccode?style=social)](https://github.com/iDevelop25/ccode)
 ---
-## Licencia
+## License
 ISC
 ---
-*CCODE no te dice como programar — te dice que construir y se asegura de que no pierdas el rumbo.*
+*CCODE doesn't tell you how to code — it tells you what to build and makes sure you don't lose track.*

package/dist/ai/deepseek.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+import { IAIProvider, IAIConfig } from './provider.js';
+/**
+ * Adaptador para DeepSeek.
+ * Usa formato compatible con OpenAI.
+ */
+export declare class DeepSeekAdapter implements IAIProvider {
+    private config;
+    constructor(config: IAIConfig);
+    getName(): string;
+    generate(prompt: string): Promise<string>;
+}

package/dist/ai/deepseek.js ADDED Viewed

@@ -0,0 +1,35 @@
+import axios from 'axios';
+/**
+ * Adaptador para DeepSeek.
+ * Usa formato compatible con OpenAI.
+ */
+export class DeepSeekAdapter {
+    config;
+    constructor(config) {
+        this.config = {
+            apiKey: config.apiKey || '',
+            model: config.model || 'deepseek-chat',
+            baseUrl: config.baseUrl || 'https://api.deepseek.com/v1/chat/completions',
+        };
+    }
+    getName() {
+        return `DeepSeek (${this.config.model})`;
+    }
+    async generate(prompt) {
+        if (!this.config.apiKey) {
+            throw new Error('API Key de DeepSeek no configurada.');
+        }
+        const response = await axios.post(this.config.baseUrl, {
+            model: this.config.model,
+            max_tokens: 8096,
+            messages: [{ role: 'user', content: prompt }],
+        }, {
+            headers: {
+                'Authorization': `Bearer ${this.config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: 120000,
+        });
+        return response.data.choices[0].message.content;
+    }
+}

package/dist/ai/gemini.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import { IAIProvider, IAIConfig } from './provider.js';
+/**
+ * Adaptador para Google Gemini.
+ */
+export declare class GeminiAdapter implements IAIProvider {
+    private config;
+    constructor(config: IAIConfig);
+    getName(): string;
+    generate(prompt: string): Promise<string>;
+}

package/dist/ai/gemini.js ADDED Viewed

@@ -0,0 +1,31 @@
+import axios from 'axios';
+/**
+ * Adaptador para Google Gemini.
+ */
+export class GeminiAdapter {
+    config;
+    constructor(config) {
+        this.config = {
+            apiKey: config.apiKey || '',
+            model: config.model || 'gemini-2.5-flash',
+            baseUrl: config.baseUrl || 'https://generativelanguage.googleapis.com/v1beta/models',
+        };
+    }
+    getName() {
+        return `Gemini (${this.config.model})`;
+    }
+    async generate(prompt) {
+        if (!this.config.apiKey) {
+            throw new Error('API Key de Google AI no configurada.');
+        }
+        const url = `${this.config.baseUrl}/${this.config.model}:generateContent?key=${this.config.apiKey}`;
+        const response = await axios.post(url, {
+            contents: [{ parts: [{ text: prompt }] }],
+            generationConfig: { maxOutputTokens: 8096 },
+        }, {
+            headers: { 'Content-Type': 'application/json' },
+            timeout: 120000,
+        });
+        return response.data.candidates[0].content.parts[0].text;
+    }
+}

package/dist/ai/groq.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+import { IAIProvider, IAIConfig } from './provider.js';
+/**
+ * Adaptador para Groq (inferencia ultra-rápida).
+ * Usa formato compatible con OpenAI.
+ */
+export declare class GroqAdapter implements IAIProvider {
+    private config;
+    constructor(config: IAIConfig);
+    getName(): string;
+    generate(prompt: string): Promise<string>;
+}

package/dist/ai/groq.js ADDED Viewed

@@ -0,0 +1,35 @@
+import axios from 'axios';
+/**
+ * Adaptador para Groq (inferencia ultra-rápida).
+ * Usa formato compatible con OpenAI.
+ */
+export class GroqAdapter {
+    config;
+    constructor(config) {
+        this.config = {
+            apiKey: config.apiKey || '',
+            model: config.model || 'llama-3.3-70b-versatile',
+            baseUrl: config.baseUrl || 'https://api.groq.com/openai/v1/chat/completions',
+        };
+    }
+    getName() {
+        return `Groq (${this.config.model})`;
+    }
+    async generate(prompt) {
+        if (!this.config.apiKey) {
+            throw new Error('API Key de Groq no configurada.');
+        }
+        const response = await axios.post(this.config.baseUrl, {
+            model: this.config.model,
+            max_tokens: 8096,
+            messages: [{ role: 'user', content: prompt }],
+        }, {
+            headers: {
+                'Authorization': `Bearer ${this.config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: 60000,
+        });
+        return response.data.choices[0].message.content;
+    }
+}

package/dist/ai/manager.d.ts CHANGED Viewed

@@ -1,6 +1,7 @@
 import { IAIProvider } from './provider.js';
+export type ProviderName = 'claude' | 'openai' | 'gemini' | 'deepseek' | 'groq' | 'ollama';
 export interface ICCODEConfig {
-    provider: 'claude' | 'ollama';
+    provider: ProviderName;
     apiKey?: string;
     model?: string;
     baseUrl?: string;

package/dist/ai/manager.js CHANGED Viewed

@@ -1,5 +1,9 @@
 import * as path from 'path';
 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';
 /**
@@ -22,6 +26,14 @@ export class AIManager {
         switch (config.provider) {
             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:

package/dist/ai/openai.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import { IAIProvider, IAIConfig } from './provider.js';
+/**
+ * Adaptador para OpenAI (ChatGPT).
+ */
+export declare class OpenAIAdapter implements IAIProvider {
+    private config;
+    constructor(config: IAIConfig);
+    getName(): string;
+    generate(prompt: string): Promise<string>;
+}

package/dist/ai/openai.js ADDED Viewed

@@ -0,0 +1,34 @@
+import axios from 'axios';
+/**
+ * Adaptador para OpenAI (ChatGPT).
+ */
+export class OpenAIAdapter {
+    config;
+    constructor(config) {
+        this.config = {
+            apiKey: config.apiKey || '',
+            model: config.model || 'gpt-4o',
+            baseUrl: config.baseUrl || 'https://api.openai.com/v1/chat/completions',
+        };
+    }
+    getName() {
+        return `OpenAI (${this.config.model})`;
+    }
+    async generate(prompt) {
+        if (!this.config.apiKey) {
+            throw new Error('API Key de OpenAI no configurada.');
+        }
+        const response = await axios.post(this.config.baseUrl, {
+            model: this.config.model,
+            max_tokens: 8096,
+            messages: [{ role: 'user', content: prompt }],
+        }, {
+            headers: {
+                'Authorization': `Bearer ${this.config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: 120000,
+        });
+        return response.data.choices[0].message.content;
+    }
+}

package/dist/cli/index.js CHANGED Viewed

@@ -39,37 +39,73 @@ async function promptAIConfig() {
             message: 'Proveedor de IA:',
             choices: [
                 { name: '  Claude (Anthropic) — Recomendado', value: 'claude' },
-                { name: '  Ollama (Local)', value: 'ollama' },
+                { 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' },
             ],
         }]);
     const config = { provider };
-    if (provider === 'claude') {
+    // 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 Anthropic:',
+                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: 'select',
+                type: 'input',
                 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' },
-                ],
+                message: 'Modelo de Ollama:',
+                default: 'llama3',
             }]);
         config.model = model;
     }
     else {
         const { model } = await inquirer.prompt([{
-                type: 'input',
+                type: 'select',
                 name: 'model',
-                message: 'Modelo de Ollama:',
-                default: 'llama3',
+                message: 'Modelo:',
+                choices: modelChoices[provider],
             }]);
         config.model = model;
     }
@@ -143,7 +179,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' });
+        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' });
         if (hasConfig) {
             choices.push({ name: '  🔌  Reconfigurar IA', value: 'connect' });
         }
@@ -175,6 +211,10 @@ async function startSession() {
             complete: handleComplete,
             status: handleStatus,
             context: handleContext,
+            update: handleUpdate,
+            export: handleExport,
+            explain: handleExplain,
+            doctor: handleDoctor,
         };
         if (handlers[action]) {
             try {
@@ -353,7 +393,7 @@ async function handleConnect() {
     }
     else {
         spinner.fail(c.error('No se pudo conectar'));
-        showError('Verifica credenciales o que Ollama esté corriendo.');
+        showError('Verifica tu API Key, conexión a internet, o que Ollama esté corriendo.');
     }
 }
 // ─── PLAN ───────────────────────────────────────────────────────────
@@ -684,13 +724,222 @@ async function handleContext() {
     }
     console.log('');
 }
+// ─── UPDATE ─────────────────────────────────────────────────────────
+async function handleUpdate() {
+    if (!(await requireInit()))
+        return;
+    const config = await requireAI();
+    if (!config)
+        return;
+    showHeader('Actualizar Contexto');
+    const spinner = ora({ text: 'Analizando proyecto...', color: 'cyan', spinner: 'dots' }).start();
+    try {
+        const ccodePath = path.join(process.cwd(), '.ccode');
+        const contextEngine = new ContextEngine();
+        await contextEngine.load();
+        const ctx = contextEngine.getContext();
+        // Leer archivos del proyecto
+        const projectFiles = listProjectFiles(process.cwd());
+        // Leer contexto actual
+        const currentProject = await FileUtils.readFileSafe(path.join(ccodePath, 'project.md'));
+        const currentArch = await FileUtils.readFileSafe(path.join(ccodePath, 'architecture.md'));
+        const currentRules = await FileUtils.readFileSafe(path.join(ccodePath, 'rules.md'));
+        spinner.text = 'Actualizando con IA...';
+        const provider = AIManager.getProvider(config);
+        const updatePrompt = `Eres un arquitecto de software. Analiza el estado ACTUAL del proyecto y actualiza la documentación existente.
+=== DOCUMENTACIÓN ACTUAL ===
+${currentProject}
+=== ARQUITECTURA ACTUAL ===
+${currentArch}
+=== REGLAS ACTUALES ===
+${currentRules}
+=== ARCHIVOS EN EL PROYECTO ===
+${projectFiles.join('\n')}
+Actualiza la documentación para reflejar los archivos y estructura actuales del proyecto. Mantén lo que siga siendo válido, actualiza lo que haya cambiado, agrega lo nuevo.
+Responde ÚNICAMENTE con JSON válido:
+{
+  "project": "Contenido actualizado de project.md",
+  "architecture": "Contenido actualizado de architecture.md",
+  "rules": "Contenido actualizado de rules.md",
+  "changes": ["Lista de cambios detectados"]
+}`;
+        const response = await provider.generate(updatePrompt);
+        const result = PromptBuilder.parseJSON(response);
+        await FileUtils.writeFile(path.join(ccodePath, 'project.md'), result.project);
+        await FileUtils.writeFile(path.join(ccodePath, 'architecture.md'), result.architecture);
+        await FileUtils.writeFile(path.join(ccodePath, 'rules.md'), result.rules);
+        spinner.succeed(c.success('Contexto actualizado'));
+        if (result.changes && result.changes.length > 0) {
+            console.log('');
+            console.log(c.accent('  Cambios detectados:'));
+            result.changes.forEach(change => console.log(c.dim(`    • ${change}`)));
+        }
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Error');
+        showError(error instanceof Error ? error.message : String(error));
+    }
+}
+// ─── EXPORT ─────────────────────────────────────────────────────────
+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.).');
+    console.log('');
+}
+// ─── EXPLAIN ────────────────────────────────────────────────────────
+async function handleExplain() {
+    if (!(await requireInit()))
+        return;
+    showHeader('Resumen del Proyecto');
+    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 taskEngine = new TaskEngine();
+    await taskEngine.load();
+    const stats = taskEngine.getStats();
+    const projectFiles = listProjectFiles(process.cwd());
+    // Extraer info clave
+    console.log(c.bold('  Proyecto'));
+    projectMd.split('\n').slice(0, 8).forEach(line => {
+        if (line.trim())
+            console.log(`  ${line}`);
+    });
+    console.log('');
+    console.log(c.bold('  Arquitectura'));
+    archMd.split('\n').slice(0, 12).forEach(line => {
+        if (line.trim())
+            console.log(`  ${line}`);
+    });
+    console.log('');
+    console.log(c.bold('  Archivos detectados'));
+    const dirs = projectFiles.filter(f => f.endsWith('/')).slice(0, 10);
+    dirs.forEach(d => console.log(c.accent(`    ${d}`)));
+    const fileCount = projectFiles.filter(f => !f.endsWith('/')).length;
+    console.log(c.dim(`    ${fileCount} archivos en total`));
+    console.log('');
+    console.log(c.bold('  Progreso'));
+    console.log(`  ${showProgressBar(stats.completed, stats.total)}`);
+    console.log(c.dim(`    ${stats.completed} completadas, ${stats.in_progress} en progreso, ${stats.pending} pendientes, ${stats.failed} fallidas`));
+    console.log('');
+}
+// ─── DOCTOR ─────────────────────────────────────────────────────────
+async function handleDoctor() {
+    if (!(await requireInit()))
+        return;
+    showHeader('Diagnóstico del Proyecto');
+    const ccodePath = path.join(process.cwd(), '.ccode');
+    let issues = 0;
+    // 1. Verificar archivos de contexto
+    const requiredFiles = [
+        { file: 'context.json', label: 'Configuración del proyecto' },
+        { file: 'state.json', label: 'Estado del workflow' },
+        { file: 'project.md', label: 'Documentación del proyecto' },
+        { file: 'architecture.md', label: 'Arquitectura' },
+        { file: 'rules.md', label: 'Reglas de desarrollo' },
+        { file: 'tasks.json', label: 'Checklist de tareas' },
+        { file: 'memory.md', label: 'Historial de decisiones' },
+    ];
+    console.log(c.bold('  Archivos de contexto'));
+    for (const { file, label } of requiredFiles) {
+        const exists = await FileUtils.exists(path.join(ccodePath, file));
+        if (exists) {
+            const content = await FileUtils.readFileSafe(path.join(ccodePath, file));
+            if (content.trim().length < 5) {
+                console.log(c.warning(`  ⚠ ${label} (${file}) — existe pero está vacío`));
+                issues++;
+            }
+            else {
+                console.log(c.success(`  ✓ ${label}`));
+            }
+        }
+        else {
+            console.log(c.error(`  ✗ ${label} (${file}) — no encontrado`));
+            issues++;
+        }
+    }
+    // 2. Proveedor de IA
+    console.log('');
+    console.log(c.bold('  Proveedor de IA'));
+    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'));
+        }
+        else {
+            spinner.fail(c.error('No se pudo conectar'));
+            issues++;
+        }
+    }
+    else {
+        console.log(c.warning(`  ⚠ No configurado — ejecuta "Conectar IA"`));
+        issues++;
+    }
+    // 3. Tareas
+    console.log('');
+    console.log(c.bold('  Tareas'));
+    const taskEngine = new TaskEngine();
+    await taskEngine.load();
+    const stats = taskEngine.getStats();
+    if (stats.total === 0) {
+        console.log(c.warning('  ⚠ No hay tareas — ejecuta "Generar plan"'));
+        issues++;
+    }
+    else {
+        console.log(c.success(`  ✓ ${stats.total} tareas en total`));
+        if (stats.completed > 0)
+            console.log(c.success(`  ✓ ${stats.completed} completadas`));
+        if (stats.in_progress > 0)
+            console.log(c.accent(`  ◐ ${stats.in_progress} en progreso`));
+        if (stats.pending > 0)
+            console.log(c.warning(`  ⚠ ${stats.pending} pendientes`));
+        if (stats.failed > 0) {
+            console.log(c.error(`  ✗ ${stats.failed} fallidas — necesitan replantearse`));
+            issues++;
+        }
+    }
+    // 4. Archivos del proyecto
+    console.log('');
+    console.log(c.bold('  Proyecto'));
+    const projectFiles = listProjectFiles(process.cwd());
+    const fileCount = projectFiles.filter(f => !f.endsWith('/')).length;
+    const dirCount = projectFiles.filter(f => f.endsWith('/')).length;
+    console.log(c.success(`  ✓ ${fileCount} archivos en ${dirCount} directorios`));
+    // Resumen
+    console.log('');
+    console.log(c.dim('  ─────────────────────────────────────────────'));
+    if (issues === 0) {
+        console.log(c.success('  ✓ Todo en orden — el proyecto está saludable'));
+    }
+    else {
+        console.log(c.warning(`  ⚠ ${issues} problema${issues > 1 ? 's' : ''} encontrado${issues > 1 ? 's' : ''}`));
+    }
+    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');
+        .version('2.2.0');
     // Comandos individuales (para uso rápido sin sesión)
     program.command('init').description('Inicializa el contexto del proyecto').action(async () => {
         await handleInit();
@@ -704,6 +953,10 @@ async function main() {
     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);
+    program.command('update').description('Re-analiza y actualiza el contexto').action(handleUpdate);
+    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);
     if (process.argv.length <= 2) {
         // Sin argumentos → sesión interactiva
         const isInitialized = await FileUtils.exists(path.join(process.cwd(), '.ccode'));

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@korl3one/ccode",
-  "version": "2.0.1",
+  "version": "2.2.0",
   "description": "CLI de contexto persistente para desarrollo asistido por IA. Genera documentacion, arquitectura, reglas y tareas verificables.",
   "type": "module",
   "main": "dist/cli/index.js",