chocolatito-code 1.0.0

package/README.md

@@ -0,0 +1,186 @@
+# 🦊 Chocolatito Code (v1.0.0)
+
+> **Agente Autónomo de Programación para la Terminal**, desarrollado por **Chocolatito** con la arquitectura del **Motor Espectro**.
+
+---
+
+## ⚡ Niveles de Potencia y Esfuerzo (/effort)
+
+Chocolatito Code te permite regular dinámicamente la profundidad y potencia del motor según la complejidad de la tarea:
+
+| Nivel | Nombre | Nivel de Esfuerzo | Uso Recomendado |
+| :--- | :--- | :---: | :--- |
+| Nivel | Modelo real | Uso recomendado |
+| :--- | :--- | :--- |
+| **`1.0`** Ágil | `deepseek-v4-flash` | Tareas cotidianas, funciones y scripts directos. |
+| **`1.5`** Avanzado | `deepseek-v4-flash` | Refactorizaciones, con más margen creativo. |
+| **`2.0`** Razonamiento Pro | `deepseek-v4-pro` | Bugs difíciles, algoritmos y arquitectura. |
+| **`2.5`** MAX | `deepseek-v4-pro` | Proyectos completos y exploración amplia. |
+
+Ventana de contexto: **1.000.000 de tokens** en los cuatro niveles.
+
+Para cambiar de nivel dentro de la sesión, escribe:
+```bash
+/effort 2.0
+```
+
+---
+
+## 🛠️ Herramientas Nativas Autónomas
+
+- 👁️ `view_file`: Lectura precisa con numeración de líneas.
+- ✏️ `edit_file`: Modificación de código con diffs visuales tipo Git (verde/rojo).
+- 📄 `write_file`: Creación y sobreescritura de archivos y directorios.
+- 💻 `run_command`: Ejecución de comandos en PowerShell/Bash con captura de logs.
+- 📂 `list_dir`: Exploración de proyectos respetando `.gitignore`.
+- 🔍 `grep_search`: Búsqueda instantánea de texto y regex.
+- 🌐 `chrome`: Controla **tu** Chrome desde dentro, con tus sesiones iniciadas y en segundo
+  plano real (requiere la extensión: ver `extension/README.md`).
+- 🖥️ `computer_use`: Aplicaciones de escritorio por árbol de accesibilidad, sin adivinar píxeles.
+- 🧭 `browser`: Navegador propio por CDP, para webs públicas y `localhost`.
+
+Las lecturas independientes lanzadas en el mismo turno se ejecutan **en paralelo**.
+
+## 🔌 MCP (Model Context Protocol)
+
+Conecta cualquier servidor MCP y sus herramientas quedan disponibles para el agente.
+Configuración compatible con Claude Code en `.mcp.json` (ver `.mcp.json.ejemplo`):
+
+```json
+{ "mcpServers": { "github": {
+    "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"],
+    "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}" } } } }
+```
+
+Las herramientas aparecen como `mcp__<servidor>__<herramienta>`. Usa `/mcp` para ver el estado.
+
+## 🪝 Hooks
+
+Reglas propias que el agente no puede saltarse, en `.chocolatito/settings.json`:
+
+```json
+{ "hooks": { "PreToolUse": [ { "matcher": "run_command",
+    "hooks": [{ "type": "command", "command": "node .chocolatito/hooks/guardia.mjs" }] } ] } }
+```
+
+El hook recibe el evento por stdin como JSON y puede **denegar**, **pedir confirmación** o
+**reescribir los argumentos** antes de que la herramienta se ejecute. Salir con código 2
+bloquea directamente.
+
+
+## 🔐 Permisos
+
+Una sola regla: **mirar es gratis, actuar se pregunta.**
+
+| Acción | Se pregunta |
+| :--- | :--- |
+| `ui_snapshot`, `list_windows`, `snapshot`, `screenshot`, `get_text`, `tabs` | No. Es el paso previo obligatorio de todo. |
+| Clic, escritura, navegación o JavaScript sobre tu ordenador o tu Chrome | **Siempre**, también en `acceptEdits`. |
+| `run_command`, escritura y borrado de archivos | Sí, salvo patrón autorizado. |
+
+### Cambiar de modo con `shift+tab`
+
+Funciona **en cualquier momento**: en el prompt, a mitad de una generación y dentro del
+propio diálogo de permiso (ahí además aprueba la acción pendiente).
+
+```
+normal  →  acepta ediciones  →  automático  →  normal
+```
+
+- **normal** — pregunta antes de cada acción con consecuencias.
+- **acepta ediciones** — escribe archivos sin preguntar; sigue preguntando por comandos y
+  por el control del ordenador.
+- **automático** — no pregunta nada.
+
+El **modo plan** se activa aparte, con `/plan`, para no dejarlo a un golpe de tecla. Es
+solo lectura de verdad: ni comandos, ni clics, ni escrituras.
+
+`--yes` aprueba todo sin preguntar: es para CI, no para el día a día.
+
+## ⌨️ Escribir mientras trabaja
+
+No hace falta esperar a que termine. Lo que escribas durante una generación aparece bajo
+el spinner y, al pulsar Enter, queda en cola: el agente acaba su turno y lo toma como
+siguiente orden, sin que tengas que volver a teclearlo.
+
+`Esc` pausa el turno en curso. `Ctrl+C` una vez interrumpe; dos veces cierra la sesión.
+
+
+---
+
+## 🔑 Licencia
+
+Al abrirlo por primera vez pide la clave que recibiste por correo al comprar:
+
+```
+🔑 ACTIVACIÓN — CHOCOLATITO CODE
+Licencia ❯ 38b1460a-5104-4067-a91d-77b872934d51
+✔ Licencia activada para tu@correo.com
+```
+
+Se guarda en `~/.chocolatitorc` y no vuelve a pedirla. Una clave sirve para **3 equipos**.
+
+```bash
+/licencia            # ver la licencia activa y en qué equipo estás
+/licencia liberar    # soltar este equipo para usar la clave en otro
+```
+
+Si cambias de ordenador o formateas, libera el equipo antes. Si ya no puedes,
+escribe al soporte y se libera desde el panel.
+
+Se comprueba una vez al día. Si algún día no hay conexión, **sigues trabajando**:
+hay 7 días de margen antes de pedirte que te conectes.
+
+---
+
+## 📦 Instalación
+
+```bash
+npm install -g chocolatito-code
+chocolatito --version
+```
+
+Requiere **Node.js 20 o superior**. La primera vez pide la API key y la guarda en
+`~/.chocolatitorc`; también se puede pasar por `CHOCOLATITO_API_KEY` o por un `.env` del
+proyecto.
+
+Para desarrollar sobre el propio proyecto:
+
+```bash
+npm install && npm run build && npm link
+```
+
+---
+
+## 🚀 Uso Rápido
+
+```bash
+# Iniciar sesión interactiva
+chocolatito
+
+# O ejecutar una orden directa
+chocolatito "crea una API REST con Node.js y Express"
+
+# Modo no interactivo: aprueba las acciones sin preguntar
+chocolatito --yes "ejecuta los tests y arregla lo que falle"
+
+# Ayuda y versión, sin gastar tokens
+chocolatito --help
+chocolatito --version
+```
+
+## 🧪 Pruebas
+
+```bash
+npm run build && npm test
+```
+
+## 📚 Documentación
+
+- `MEJORAS.md` — auditoría del núcleo y de permisos: qué estaba roto, qué se arregló y cómo se comprobó.
+- `COMPUTER-USE.md` — diseño del control de ordenador y navegador.
+- `extension/README.md` — instalación de la extensión de Chrome.
+
+---
+
+Desarrollado con pasión por **Chocolatito**. 🦊⚡

package/dist/agent/context.d.ts

@@ -0,0 +1,9 @@
+export interface ProjectContext {
+    cwd: string;
+    os: string;
+    rulesContent: string | null;
+    gitBranch: string | null;
+    projectType: string;
+    availableScripts: string[];
+}
+export declare function getProjectContext(cwd?: string): Promise<ProjectContext>;

package/dist/agent/context.js

@@ -0,0 +1,123 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execa } from "execa";
+import { RULES_FILE_NAME } from "../config/constants.js";
+export async function getProjectContext(cwd = process.cwd()) {
+    let rulesContent = null;
+    // 1. Look for CHOCOLATITO.md or CLAUDE.md
+    const rulesPath = path.join(cwd, RULES_FILE_NAME);
+    const fallbackClaudePath = path.join(cwd, "CLAUDE.md");
+    if (fs.existsSync(rulesPath)) {
+        try {
+            rulesContent = fs.readFileSync(rulesPath, "utf-8");
+        }
+        catch { }
+    }
+    else if (fs.existsSync(fallbackClaudePath)) {
+        try {
+            rulesContent = fs.readFileSync(fallbackClaudePath, "utf-8");
+        }
+        catch { }
+    }
+    // 2. Git branch & status detection
+    let gitBranch = null;
+    try {
+        const { stdout: branchOut } = await execa("git", ["branch", "--show-current"], { cwd });
+        if (branchOut && branchOut.trim()) {
+            const branchName = branchOut.trim();
+            const { stdout: statusOut } = await execa("git", ["status", "--porcelain"], { cwd });
+            const changedFiles = statusOut ? statusOut.trim().split("\n").filter(Boolean).length : 0;
+            gitBranch = changedFiles > 0 ? `${branchName} (${changedFiles} archivos modificados)` : `${branchName} (limpio)`;
+        }
+    }
+    catch { }
+    // 3. Comprehensive project type & available scripts detection
+    let projectType = "Desconocido / Genérico";
+    const availableScripts = [];
+    const pkgJsonPath = path.join(cwd, "package.json");
+    const pyProjectPath = path.join(cwd, "pyproject.toml");
+    const reqTxtPath = path.join(cwd, "requirements.txt");
+    const cargoPath = path.join(cwd, "Cargo.toml");
+    const goModPath = path.join(cwd, "go.mod");
+    const pubspecPath = path.join(cwd, "pubspec.yaml");
+    const gradlePath = path.join(cwd, "build.gradle");
+    const pomPath = path.join(cwd, "pom.xml");
+    const cmakePath = path.join(cwd, "CMakeLists.txt");
+    if (fs.existsSync(pkgJsonPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+            const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+            const tech = [];
+            if (deps.react)
+                tech.push("React");
+            if (deps.next)
+                tech.push("Next.js");
+            if (deps.remotion)
+                tech.push("Remotion");
+            if (deps.vue)
+                tech.push("Vue");
+            if (deps.svelte)
+                tech.push("Svelte");
+            if (deps.express)
+                tech.push("Express");
+            if (deps.fastify)
+                tech.push("Fastify");
+            if (deps.nest || deps["@nestjs/core"])
+                tech.push("NestJS");
+            if (deps.typescript)
+                tech.push("TypeScript");
+            if (deps.tailwindcss)
+                tech.push("Tailwind CSS");
+            projectType = `Node.js / JavaScript${tech.length > 0 ? ` (${tech.join(", ")})` : ""}`;
+            if (pkg.scripts) {
+                Object.keys(pkg.scripts).forEach((k) => availableScripts.push(`npm run ${k}`));
+            }
+        }
+        catch { }
+    }
+    else if (fs.existsSync(pyProjectPath) || fs.existsSync(reqTxtPath)) {
+        let framework = "";
+        try {
+            const content = (fs.existsSync(reqTxtPath) ? fs.readFileSync(reqTxtPath, "utf-8") : "") +
+                (fs.existsSync(pyProjectPath) ? fs.readFileSync(pyProjectPath, "utf-8") : "");
+            if (content.includes("fastapi"))
+                framework = " (FastAPI)";
+            else if (content.includes("django"))
+                framework = " (Django)";
+            else if (content.includes("flask"))
+                framework = " (Flask)";
+            else if (content.includes("torch"))
+                framework = " (PyTorch)";
+        }
+        catch { }
+        projectType = `Python${framework}`;
+        availableScripts.push("python main.py", "pytest");
+    }
+    else if (fs.existsSync(cargoPath)) {
+        projectType = "Rust (Cargo)";
+        availableScripts.push("cargo build", "cargo test", "cargo run");
+    }
+    else if (fs.existsSync(goModPath)) {
+        projectType = "Go (Golang)";
+        availableScripts.push("go build", "go test", "go run .");
+    }
+    else if (fs.existsSync(pubspecPath)) {
+        projectType = "Flutter / Dart";
+        availableScripts.push("flutter run", "flutter test");
+    }
+    else if (fs.existsSync(gradlePath) || fs.existsSync(pomPath)) {
+        projectType = "Java / Kotlin (JVM)";
+    }
+    else if (fs.existsSync(cmakePath)) {
+        projectType = "C / C++ (CMake)";
+    }
+    const osName = process.platform === "win32" ? "Windows" : process.platform === "darwin" ? "macOS" : "Linux";
+    return {
+        cwd,
+        os: osName,
+        rulesContent,
+        gitBranch,
+        projectType,
+        availableScripts,
+    };
+}

package/dist/agent/fileTracker.d.ts

@@ -0,0 +1,16 @@
+declare class FileTracker {
+    private seen;
+    private key;
+    /** Se llama tras leer un archivo con exito. */
+    markRead(filePath: string, cwd: string): void;
+    /** Se llama tras escribir, para que la siguiente edicion no se queje. */
+    markWritten(filePath: string, cwd: string): void;
+    forget(filePath: string, cwd: string): void;
+    /**
+     * Devuelve un aviso si editar este archivo ahora seria arriesgado, o null si
+     * todo esta en orden.
+     */
+    checkBeforeEdit(filePath: string, cwd: string): string | null;
+}
+export declare const fileTracker: FileTracker;
+export {};

package/dist/agent/fileTracker.js

@@ -0,0 +1,53 @@
+import fs from "node:fs";
+import path from "node:path";
+class FileTracker {
+    seen = new Map();
+    key(filePath, cwd) {
+        const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+        return path.normalize(abs).toLowerCase();
+    }
+    /** Se llama tras leer un archivo con exito. */
+    markRead(filePath, cwd) {
+        try {
+            const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+            const st = fs.statSync(abs);
+            this.seen.set(this.key(filePath, cwd), { mtimeMs: st.mtimeMs, size: st.size });
+        }
+        catch {
+            // Si no se puede medir, no se registra: mejor pedir lectura de nuevo.
+        }
+    }
+    /** Se llama tras escribir, para que la siguiente edicion no se queje. */
+    markWritten(filePath, cwd) {
+        this.markRead(filePath, cwd);
+    }
+    forget(filePath, cwd) {
+        this.seen.delete(this.key(filePath, cwd));
+    }
+    /**
+     * Devuelve un aviso si editar este archivo ahora seria arriesgado, o null si
+     * todo esta en orden.
+     */
+    checkBeforeEdit(filePath, cwd) {
+        const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+        if (!fs.existsSync(abs))
+            return null;
+        const record = this.seen.get(this.key(filePath, cwd));
+        if (!record) {
+            return (`No has leido "${filePath}" en esta sesion. Usa view_file antes de editarlo: ` +
+                `editar un contenido que no has visto es como se sobrescribe la parte equivocada.`);
+        }
+        try {
+            const st = fs.statSync(abs);
+            if (st.mtimeMs > record.mtimeMs + 1 || st.size !== record.size) {
+                return (`"${filePath}" cambio despues de que lo leyeras (otro proceso, el usuario o un formateador). ` +
+                    `Vuelve a leerlo con view_file antes de editar, o perderas esos cambios.`);
+            }
+        }
+        catch {
+            return null;
+        }
+        return null;
+    }
+}
+export const fileTracker = new FileTracker();

package/dist/agent/loop.d.ts

@@ -0,0 +1,25 @@
+import OpenAI from "openai";
+import { TokenTracker } from "./tracker.js";
+import { EspectroModel } from "../config/constants.js";
+import { PermissionManager } from "../config/permissions.js";
+import { HookManager } from "../hooks/manager.js";
+export declare class AgentLoop {
+    private client;
+    private currentEspectro;
+    messages: OpenAI.Chat.ChatCompletionMessageParam[];
+    tracker: TokenTracker;
+    currentCwd: string;
+    permissions: PermissionManager;
+    hooks: HookManager;
+    private apiKey;
+    private baseURL;
+    private maxIterations;
+    constructor(apiKey: string, baseURL: string, initialModel: EspectroModel, systemPrompt: string);
+    setEspectroModel(model: EspectroModel, updatedSystemPrompt?: string): void;
+    getEspectroModel(): EspectroModel;
+    clearHistory(systemPrompt: string): void;
+    compactHistory(systemPrompt: string): Promise<string>;
+    lastTurnTokens: number;
+    autoCompactIfNeeded(): Promise<boolean>;
+    runTask(userPrompt: string): Promise<void>;
+}