chocolatito-code 1.0.0

package/dist/hooks/manager.js

@@ -0,0 +1,193 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { execa } from "execa";
+const DEFAULT_TIMEOUT_MS = 30_000;
+export class HookManager {
+    config = {};
+    disabled = false;
+    cwd;
+    constructor(cwd = process.cwd()) {
+        this.cwd = cwd;
+        this.load();
+    }
+    /** settings.json del usuario y del proyecto; el proyecto tiene prioridad. */
+    load() {
+        const paths = [
+            path.join(os.homedir(), ".chocolatito", "settings.json"),
+            path.join(this.cwd, ".chocolatito", "settings.json"),
+        ];
+        for (const p of paths) {
+            if (!fs.existsSync(p))
+                continue;
+            try {
+                const parsed = JSON.parse(fs.readFileSync(p, "utf-8"));
+                if (parsed.disableAllHooks === true)
+                    this.disabled = true;
+                for (const [event, matchers] of Object.entries(parsed.hooks || {})) {
+                    const key = event;
+                    this.config[key] = [...(this.config[key] || []), ...matchers];
+                }
+            }
+            catch {
+                // Un settings.json roto no debe impedir arrancar.
+            }
+        }
+    }
+    get hasHooks() {
+        return !this.disabled && Object.keys(this.config).length > 0;
+    }
+    describe() {
+        if (this.disabled)
+            return "Los hooks estan desactivados (disableAllHooks).";
+        const events = Object.keys(this.config);
+        if (events.length === 0) {
+            return ("No hay hooks configurados.\n\n" +
+                "Se definen en .chocolatito/settings.json:\n" +
+                JSON.stringify({
+                    hooks: {
+                        PreToolUse: [
+                            {
+                                matcher: "run_command",
+                                hooks: [{ type: "command", command: "node .chocolatito/hooks/guardia.mjs" }],
+                            },
+                        ],
+                    },
+                }, null, 2));
+        }
+        const lines = ["HOOKS CONFIGURADOS:"];
+        for (const e of events) {
+            for (const m of this.config[e] || []) {
+                for (const h of m.hooks) {
+                    lines.push(`  ${e} [${m.matcher || "*"}] → ${h.command}`);
+                }
+            }
+        }
+        return lines.join("\n");
+    }
+    /**
+     * El matcher sigue las reglas de Claude Code: vacio o "*" vale para todo, un
+     * texto simple (o lista con "|") compara exacto, y cualquier otra cosa se
+     * trata como expresion regular.
+     */
+    matches(matcher, value) {
+        if (!matcher || matcher === "*" || matcher.trim() === "")
+            return true;
+        if (/^[A-Za-z0-9_\-, |]+$/.test(matcher)) {
+            return matcher
+                .split("|")
+                .map((s) => s.trim())
+                .filter(Boolean)
+                .includes(value);
+        }
+        try {
+            return new RegExp(matcher).test(value);
+        }
+        catch {
+            return false;
+        }
+    }
+    hooksFor(event, matchValue) {
+        if (this.disabled)
+            return [];
+        const out = [];
+        for (const m of this.config[event] || []) {
+            if (this.matches(m.matcher, matchValue))
+                out.push(...m.hooks);
+        }
+        return out;
+    }
+    /**
+     * Ejecuta los hooks del evento y devuelve la decision combinada.
+     * Gana el veto: si CUALQUIER hook deniega, se deniega.
+     */
+    async run(event, payload, matchValue = "") {
+        const hooks = this.hooksFor(event, matchValue);
+        if (hooks.length === 0)
+            return {};
+        const input = JSON.stringify({
+            hook_event_name: event,
+            cwd: this.cwd,
+            session_id: process.env.CHOCOLATITO_SESSION_ID || "",
+            ...payload,
+        });
+        const decision = {};
+        const contextos = [];
+        for (const hook of hooks) {
+            try {
+                const usaPowerShell = hook.shell === "powershell" || (hook.shell !== "bash" && process.platform === "win32");
+                // PowerShell NO propaga el codigo de salida del programa que ejecuta:
+                // powershell.exe sale con 0 aunque el hook haya salido con 2. Sin este
+                // "exit $LASTEXITCODE", el bloqueo por codigo de salida no funcionaba en
+                // Windows y el hook parecia estar aprobando siempre.
+                const comando = usaPowerShell ? `${hook.command}; exit $LASTEXITCODE` : hook.command;
+                const res = await execa(comando, {
+                    cwd: this.cwd,
+                    shell: usaPowerShell ? "powershell.exe" : "/bin/bash",
+                    input,
+                    timeout: hook.timeout ? hook.timeout * 1000 : DEFAULT_TIMEOUT_MS,
+                    reject: false,
+                    env: { ...process.env, CHOCOLATITO_PROJECT_DIR: this.cwd },
+                });
+                // Codigo 2 = bloqueo. No se puede sobrescribir con JSON: es el atajo
+                // para un hook de una linea que solo quiere decir "aqui no".
+                if (res.exitCode === 2) {
+                    decision.permissionDecision = "deny";
+                    decision.permissionDecisionReason =
+                        (res.stderr || res.stdout || "").trim() || `El hook "${hook.command}" bloqueo la accion.`;
+                    return decision;
+                }
+                const salida = (res.stdout || "").trim();
+                if (!salida)
+                    continue;
+                if (salida.startsWith("{")) {
+                    let parsed;
+                    try {
+                        parsed = JSON.parse(salida);
+                    }
+                    catch {
+                        contextos.push(salida);
+                        continue;
+                    }
+                    const esp = parsed.hookSpecificOutput || {};
+                    if (parsed.decision === "block") {
+                        decision.permissionDecision = "deny";
+                        decision.permissionDecisionReason = parsed.reason || "Bloqueado por un hook.";
+                        return decision;
+                    }
+                    if (esp.permissionDecision === "deny") {
+                        decision.permissionDecision = "deny";
+                        decision.permissionDecisionReason = esp.permissionDecisionReason || "Bloqueado por un hook.";
+                        return decision;
+                    }
+                    // "allow" no gana sobre un "deny" posterior: por eso no se corta aqui.
+                    if (esp.permissionDecision && !decision.permissionDecision) {
+                        decision.permissionDecision = esp.permissionDecision;
+                        decision.permissionDecisionReason = esp.permissionDecisionReason;
+                    }
+                    if (esp.updatedInput)
+                        decision.updatedInput = { ...(decision.updatedInput || {}), ...esp.updatedInput };
+                    if (esp.additionalContext)
+                        contextos.push(esp.additionalContext);
+                    if (parsed.systemMessage)
+                        decision.systemMessage = parsed.systemMessage;
+                }
+                else {
+                    // Salida en texto plano: se trata como contexto extra.
+                    contextos.push(salida);
+                }
+            }
+            catch (err) {
+                contextos.push(`[hook "${hook.command}" fallo: ${err?.message || err}]`);
+            }
+        }
+        if (contextos.length > 0)
+            decision.additionalContext = contextos.join("\n");
+        return decision;
+    }
+    /** Compatibilidad con la API anterior. */
+    async triggerHook(event, context) {
+        const d = await this.run(event, context);
+        return d.additionalContext || null;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,470 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+import { ensureApiKey } from "./config/env.js";
+import { ensureLicense, licenseStatus, deactivate, getStoredLicense } from "./config/license.js";
+import { isManagedMode } from "./config/quota.js";
+import { getEngineBaseUrl, DEFAULT_ESPECTRO, ESPECTRO_MODELS, RULES_FILE_NAME } from "./config/constants.js";
+import { getProjectContext } from "./agent/context.js";
+import { buildSystemPrompt } from "./prompts/systemPrompt.js";
+import { AgentLoop } from "./agent/loop.js";
+import { showBanner, animateStartupBanner, showHelp, showEffortMenu } from "./ui/banner.js";
+import { askInteractivePrompt, SLASH_COMMANDS } from "./ui/prompt.js";
+import { changeDir } from "./tools/changeDir.js";
+import { gitDiff, gitCommit } from "./tools/gitTools.js";
+import { renderUserPrompt } from "./ui/renderer.js";
+import { parseFileMentions, buildPromptWithMentions } from "./agent/mentions.js";
+import { SkillManager } from "./skills/manager.js";
+import { MemoryManager } from "./memory/manager.js";
+import { HookManager } from "./hooks/manager.js";
+import { SessionManager } from "./sessions/manager.js";
+import { globalUndoManager } from "./agent/undoManager.js";
+import { setAutoApprove } from "./ui/permissionPrompt.js";
+import { onModeChange, getMode, modeAnnouncement } from "./ui/modes.js";
+import { releaseKeyboard } from "./ui/interrupt.js";
+import { takeQueued, resetTypeAhead } from "./ui/typeAhead.js";
+import { mcpManager } from "./mcp/manager.js";
+/**
+ * Version leida del package.json instalado, no escrita a mano: una constante
+ * duplicada aqui se queda vieja en cuanto se publica una version nueva.
+ */
+function readVersion() {
+    try {
+        const here = path.dirname(fileURLToPath(import.meta.url));
+        const pkg = JSON.parse(fs.readFileSync(path.resolve(here, "..", "package.json"), "utf-8"));
+        return String(pkg.version || "desconocida");
+    }
+    catch {
+        return "desconocida";
+    }
+}
+/**
+ * Banderas que se resuelven sin arrancar el agente.
+ *
+ * Antes no existian: "chocolatito --version" se tomaba como una peticion al
+ * modelo, pedia la API key, gastaba tokens y contestaba lo que le pareciera.
+ * Un usuario que acaba de instalar el CLI escribe eso o --help lo primero.
+ */
+function handleFlags(argv) {
+    if (argv.includes("--version") || argv.includes("-v")) {
+        console.log(`chocolatito-code v${readVersion()}`);
+        return true;
+    }
+    if (argv.includes("--help") || argv.includes("-h")) {
+        const v = readVersion();
+        console.log([
+            `\nChocolatito Code v${v} — agente autonomo de programacion para la terminal.\n`,
+            "USO",
+            "  chocolatito                      Sesion interactiva.",
+            '  chocolatito "haz X"              Ejecuta una orden y termina.',
+            "",
+            "OPCIONES",
+            "  -y, --yes         Aprueba las acciones sin preguntar (util en CI).",
+            "  -v, --version     Muestra la version instalada.",
+            "  -h, --help        Muestra esta ayuda.",
+            "",
+            "DENTRO DE LA SESION",
+            "  /effort 1.0|1.5|2.0|2.5   Cambia el nivel de potencia del motor.",
+            "  /mcp                      Estado de los servidores MCP conectados.",
+            "  /undo                     Deshace el ultimo cambio en archivos.",
+            "  /resume [id]              Reanuda una sesion guardada.",
+            "  /exit                     Salir.",
+            "",
+            "CONFIGURACION",
+            "  API key: variable CHOCOLATITO_API_KEY, un .env del proyecto o ~/.chocolatitorc.",
+            "  Reglas del proyecto: CHOCOLATITO.md. Permisos y hooks: .chocolatito/settings.json.",
+            "",
+        ].join("\n"));
+        return true;
+    }
+    return false;
+}
+/**
+ * Devuelve la terminal como estaba.
+ *
+ * Mientras el agente trabaja, stdin esta en modo crudo: sin eco y sin edicion de
+ * linea. Si el proceso muere ahi (una excepcion, un kill), el usuario se queda
+ * con una terminal en la que escribe y no ve nada, y tiene que ejecutar 'reset'
+ * a ciegas. Restaurarlo cuesta tres lineas.
+ */
+function restaurarTerminal() {
+    try {
+        releaseKeyboard();
+    }
+    catch { }
+    try {
+        if (process.stdin.isTTY && process.stdin.setRawMode)
+            process.stdin.setRawMode(false);
+    }
+    catch { }
+    try {
+        process.stdout.write("\x1b[?25h"); // cursor visible
+    }
+    catch { }
+}
+function instalarRedDeSeguridad() {
+    process.on("exit", restaurarTerminal);
+    // Una promesa sin capturar no deberia costarle al usuario la sesion entera,
+    // con todo su contexto. Se avisa y se sigue.
+    process.on("unhandledRejection", (motivo) => {
+        console.log(chalk.yellow(`\n⚠ Fallo en segundo plano: ${motivo?.message || String(motivo)}`) +
+            chalk.gray("\n  La sesion continua. Si se repite, reinicia con /clear.\n"));
+    });
+    // Una excepcion no capturada si es terminal, pero al menos se sale con la
+    // terminal usable y con un mensaje legible en vez de una traza cruda.
+    process.on("uncaughtException", (err) => {
+        restaurarTerminal();
+        console.log(chalk.red(`\n✖ Error inesperado: ${err?.message || String(err)}\n`) +
+            chalk.gray(`${(err?.stack || "").split("\n").slice(1, 4).join("\n")}\n`));
+        process.exit(1);
+    });
+}
+async function main() {
+    if (handleFlags(process.argv.slice(2)))
+        return;
+    instalarRedDeSeguridad();
+    // La licencia va ANTES de la API key: no tiene sentido pedirle a alguien que
+    // configure DeepSeek si despues le vamos a decir que no ha comprado.
+    if (!(await ensureLicense())) {
+        process.exit(1);
+    }
+    // En suscripcion el motor lo paga Chocolatito: el cliente NO tiene ni necesita
+    // clave de DeepSeek, y su credencial es la propia licencia. Preguntarsela era
+    // dejarle atascado en una pantalla que no puede contestar.
+    const apiKey = isManagedMode()
+        ? getStoredLicense()?.key || (await ensureApiKey())
+        : await ensureApiKey();
+    const context = await getProjectContext(process.cwd());
+    const skillManager = new SkillManager(context.cwd);
+    const memoryManager = new MemoryManager();
+    const hookManager = new HookManager(context.cwd);
+    const sessionManager = new SessionManager();
+    const sessionId = `session_${Date.now()}`;
+    let currentModel = DEFAULT_ESPECTRO;
+    let isPlanMode = false;
+    let systemPrompt = buildSystemPrompt(context, currentModel, skillManager, memoryManager, isPlanMode);
+    const agent = new AgentLoop(apiKey, getEngineBaseUrl(), currentModel, systemPrompt);
+    // Shift+Tab (en el prompt, durante la generacion o dentro del propio dialogo)
+    // cambia el modo de permisos del agente al vuelo. El modo plan no entra en el
+    // ciclo: se sigue activando con /plan, para no dejarlo a un golpe de tecla.
+    onModeChange((modo) => {
+        if (!isPlanMode)
+            agent.permissions.setMode(modo);
+    });
+    // Trigger SessionStart hook if configured
+    await hookManager.triggerHook("SessionStart", { cwd: context.cwd, model: currentModel.name });
+    // Servidores MCP: se conectan en segundo plano para no retrasar el arranque.
+    // Si tardan, el primer turno los espera; el usuario ya puede escribir.
+    const mcpReady = mcpManager.loadAll().then((resumen) => {
+        if (resumen) {
+            console.log(chalk.hex("#D97757")("\n🔌 Servidores MCP:"));
+            console.log(resumen);
+            console.log(chalk.gray(`   ${mcpManager.toolCount} herramientas MCP disponibles.\n`));
+        }
+        return resumen;
+    });
+    // Add /resume to slash commands
+    if (!SLASH_COMMANDS.some((c) => c.name === "/licencia")) {
+        SLASH_COMMANDS.push({ name: "/licencia", description: "Ver la licencia activa o liberar este equipo", args: "[liberar]" });
+    }
+    if (!SLASH_COMMANDS.some((c) => c.name === "/resume")) {
+        SLASH_COMMANDS.splice(1, 0, { name: "/resume", description: "Reanudar una sesión anterior guardada", args: "[id]" });
+    }
+    // Single-command mode: chocolatito "crea index.html"
+    const rawArgs = process.argv.slice(2);
+    // --yes / -y aprueba las acciones sin preguntar. Util en modo comando unico y CI.
+    const autoYes = rawArgs.includes("--yes") || rawArgs.includes("-y");
+    if (autoYes)
+        setAutoApprove(true);
+    const args = rawArgs.filter((a) => a !== "--yes" && a !== "-y");
+    if (args.length > 0) {
+        const singlePrompt = args.join(" ");
+        showBanner(context.cwd, currentModel, "idle");
+        renderUserPrompt(singlePrompt);
+        const { attachedFiles } = parseFileMentions(singlePrompt, context.cwd);
+        const enrichedPrompt = buildPromptWithMentions(singlePrompt, attachedFiles);
+        await mcpReady;
+        await agent.runTask(enrichedPrompt);
+        process.exit(0);
+    }
+    // Interactive REPL Mode with lively startup walking animation
+    await animateStartupBanner(context.cwd, currentModel);
+    // El atajo hay que anunciarlo: un modo que nadie sabe que existe no sirve.
+    console.log(chalk.gray("  shift+tab cambia el modo de permisos · puedes escribir mientras trabaja y se encola\n"));
+    if (getMode() !== "default")
+        console.log(`  ${modeAnnouncement()}\n`);
+    // Lo que el usuario escribio mientras el agente trabajaba entra como siguiente
+    // orden, sin tener que volver a teclearlo.
+    let pendiente = null;
+    while (true) {
+        let userInput = "";
+        if (pendiente) {
+            userInput = pendiente;
+            pendiente = null;
+            renderUserPrompt(userInput);
+        }
+        else {
+            try {
+                userInput = await askInteractivePrompt(isPlanMode ? chalk.cyan("plan ❯") : "❯", agent.currentCwd);
+            }
+            catch {
+                console.log(chalk.gray("\n👋 Sesión finalizada."));
+                await hookManager.triggerHook("SessionEnd", { sessionId, cwd: agent.currentCwd });
+                process.exit(0);
+            }
+        }
+        const trimmed = userInput.trim();
+        if (!trimmed)
+            continue;
+        // Handle Slash Commands
+        if (trimmed === "/exit" || trimmed === "exit" || trimmed === "quit") {
+            console.log(chalk.gray("\n👋 Sesión finalizada."));
+            await hookManager.triggerHook("SessionEnd", { sessionId, cwd: agent.currentCwd });
+            process.exit(0);
+        }
+        if (trimmed === "/licencia" || trimmed.startsWith("/licencia ")) {
+            const sub = trimmed.slice("/licencia".length).trim();
+            if (sub === "liberar") {
+                const res = await deactivate();
+                console.log(res.ok ? chalk.green(`\n${res.message}\n`) : chalk.yellow(`\n${res.message}\n`));
+            }
+            else {
+                console.log(`\n${licenseStatus()}\n`);
+            }
+            continue;
+        }
+        if (trimmed === "/undo") {
+            const undoRes = globalUndoManager.undoLast();
+            if (undoRes.success) {
+                console.log(chalk.green(`\n${undoRes.message}`));
+                undoRes.restoredFiles.forEach((f) => console.log(`  ${chalk.gray("•")} ${chalk.white(f)}`));
+                console.log("");
+            }
+            else {
+                console.log(chalk.yellow(`\n⚠ ${undoRes.message}\n`));
+            }
+            continue;
+        }
+        if (trimmed.startsWith("/export")) {
+            const targetName = trimmed.slice(7).trim() || `chocolatito_session_${Date.now()}.md`;
+            const exportPath = path.isAbsolute(targetName) ? targetName : path.resolve(agent.currentCwd, targetName);
+            const sessionData = agent.messages
+                .filter((m) => m.role === "user" || m.role === "assistant")
+                .map((m) => `### 👤 ${m.role === "user" ? "Usuario" : "Chocolatito"}\n\n${typeof m.content === "string" ? m.content : JSON.stringify(m.content, null, 2)}\n`)
+                .join("\n---\n\n");
+            const mdContent = `# 🦊 Bitácora de Sesión — Chocolatito Code
+**Fecha:** ${new Date().toLocaleString()}  
+**Directorio:** \`${agent.currentCwd}\`  
+**Motor:** ${currentModel.name}  
+**Inversión Total:** ${agent.tracker.calculateCost(undefined, undefined, undefined, currentModel.underlyingModel).formattedCost}  
+
+---
+
+${sessionData}
+`;
+            fs.writeFileSync(exportPath, mdContent, "utf-8");
+            console.log(chalk.green(`\n✔ Bitácora exportada exitosamente en: ${chalk.bold.white(exportPath)}\n`));
+            continue;
+        }
+        if (trimmed === "/help") {
+            showHelp();
+            continue;
+        }
+        if (trimmed.startsWith("/resume")) {
+            const targetId = trimmed.slice(7).trim();
+            const loaded = targetId ? sessionManager.loadSession(targetId) : sessionManager.loadLatestSession();
+            if (loaded) {
+                agent.messages = loaded.messages;
+                console.log(chalk.green(`\n✔ Sesión "${loaded.id}" restaurada con éxito (${loaded.messages.length} mensajes cargados).\n`));
+            }
+            else {
+                const available = sessionManager.listSessions();
+                console.log(chalk.yellow("\n⚠ No se encontró la sesión solicitada. Sesiones disponibles:"));
+                available.forEach((s) => console.log(`  • ${chalk.white(s.id)} (${s.updatedAt}) en ${chalk.gray(s.cwd)}`));
+                console.log("");
+            }
+            continue;
+        }
+        if (trimmed === "/plan") {
+            isPlanMode = !isPlanMode;
+            agent.permissions.setMode(isPlanMode ? "plan" : "default");
+            const refreshedContext = await getProjectContext(agent.currentCwd);
+            systemPrompt = buildSystemPrompt(refreshedContext, currentModel, skillManager, memoryManager, isPlanMode);
+            agent.setEspectroModel(currentModel, systemPrompt);
+            if (isPlanMode) {
+                console.log(chalk.cyan.bold("\n📋 MODO PLAN ACTIVADO (Solo lectura)") +
+                    chalk.gray("\n  El agente investigará y propondrá planes de arquitectura sin modificar ningún archivo.\n  Escribe /plan nuevamente para desactivarlo.\n"));
+            }
+            else {
+                console.log(chalk.green.bold("\n🚀 MODO PLAN DESACTIVADO (Modo ejecución normal)") +
+                    chalk.gray("\n  Permisos de edición y ejecución habilitados.\n"));
+            }
+            continue;
+        }
+        if (trimmed === "/mcp") {
+            await mcpReady;
+            console.log(chalk.bold.hex("#D97757")("\n🔌 MODEL CONTEXT PROTOCOL"));
+            console.log(mcpManager.describe());
+            console.log("");
+            continue;
+        }
+        if (trimmed === "/skills") {
+            const skills = skillManager.scanSkills();
+            console.log(chalk.bold.hex("#D97757")("\n🧩 SKILLS DISPONIBLES (Carga diferida):"));
+            if (skills.length === 0) {
+                console.log(chalk.gray("  No hay skills en ~/.chocolatito/skills ni ~/.claude/skills.\n"));
+            }
+            else {
+                skills.forEach((s) => {
+                    console.log(`  ${chalk.hex("#A855F7")("•")} ${chalk.bold.white(s.name)}\n    ${chalk.gray(s.description)}`);
+                });
+                console.log(chalk.italic.gray("\n  (Chocolatito cargará el contenido completo automáticamente cuando sea necesario).\n"));
+            }
+            continue;
+        }
+        if (trimmed === "/memory") {
+            console.log(chalk.bold.hex("#A855F7")("\n🧠 ÍNDICE DE MEMORIA PERSISTENTE (~/.chocolatito/memory/):"));
+            console.log(chalk.gray(memoryManager.getMemoryIndex()) + "\n");
+            continue;
+        }
+        if (trimmed.startsWith("/goal")) {
+            const goalText = trimmed.slice(5).trim();
+            if (!goalText) {
+                console.log(chalk.yellow("\n⚠ Uso: /goal <descripción de la meta compleja>\n"));
+                continue;
+            }
+            console.log(chalk.bold.hex("#A855F7")("\n🎯 INICIANDO MODO META AUTÓNOMA (GOAL MODE):"));
+            console.log(chalk.gray(`  Objetivo: "${goalText}"\n`));
+            const autonomousPrompt = `[MODO META AUTÓNOMA ACTIVADO]
+Tu objetivo principal es: "${goalText}"
+Directivas de ejecución:
+1. Formula un plan de ejecución mental paso a paso.
+2. Ejecuta cada paso utilizando las herramientas correspondientes (creación, edición, ejecución, verificación).
+3. Si algo falla o hay errores, autocorregir inmediatamente y volver a probar.
+4. No te detengas hasta verificar que el objetivo esté 100% completado con éxito.`;
+            renderUserPrompt(`/goal ${goalText}`);
+            await agent.runTask(autonomousPrompt);
+            sessionManager.saveSession({
+                id: sessionId,
+                cwd: agent.currentCwd,
+                modelId: currentModel.id,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                messages: agent.messages,
+            });
+            continue;
+        }
+        if (trimmed === "/compact") {
+            const refreshedContext = await getProjectContext(agent.currentCwd);
+            const res = await agent.compactHistory(buildSystemPrompt(refreshedContext, currentModel, skillManager, memoryManager, isPlanMode));
+            console.log(chalk.green(`\n${res}\n`));
+            continue;
+        }
+        if (trimmed === "/diff") {
+            const diffOut = await gitDiff(false, agent.currentCwd);
+            console.log(chalk.bold.hex("#D97757")("\n📝 DIFERENCIAS DE GIT (DIFF):"));
+            console.log(diffOut ? chalk.gray(diffOut) : chalk.green("✔ Sin cambios pendientes.") + "\n");
+            continue;
+        }
+        if (trimmed.startsWith("/commit")) {
+            const msg = trimmed.slice(7).trim();
+            if (!msg) {
+                console.log(chalk.yellow("\n⚠ Uso: /commit <mensaje del commit>\n"));
+            }
+            else {
+                const commitRes = await gitCommit(msg, true, agent.currentCwd);
+                console.log(chalk.green(`\n${commitRes}\n`));
+            }
+            continue;
+        }
+        if (trimmed.startsWith("/cd")) {
+            const target = trimmed.slice(3).trim() || "~";
+            const res = await changeDir(target, agent.currentCwd);
+            if (res.success) {
+                agent.currentCwd = res.newCwd;
+                const refreshedContext = await getProjectContext(agent.currentCwd);
+                systemPrompt = buildSystemPrompt(refreshedContext, currentModel, skillManager, memoryManager, isPlanMode);
+                agent.clearHistory(systemPrompt);
+                console.clear();
+                showBanner(agent.currentCwd, currentModel, "happy");
+                console.log(chalk.green(`✔ ${res.message}\n`));
+            }
+            else {
+                console.log(chalk.red(`\n${res.message}\n`));
+            }
+            continue;
+        }
+        if (trimmed === "/cost") {
+            const { formattedCost, inputCost, outputCost } = agent.tracker.calculateCost(undefined, undefined, undefined, currentModel.underlyingModel);
+            console.log(chalk.bold.hex("#A855F7")("\n📊 REPORTE DE CONSUMO DE SESIÓN:") +
+                `\n  ${chalk.gray("• Motor activo:")}    ${chalk.bold.white(currentModel.name)}` +
+                `\n  ${chalk.gray("• Tokens entrada:")}  ${agent.tracker.totalPromptTokens.toLocaleString()} ($${inputCost.toFixed(5)} USD)` +
+                `\n  ${chalk.gray("• Tokens memoria:")}  ${agent.tracker.cachedPromptTokens.toLocaleString()} (90% de ahorro en caché)` +
+                `\n  ${chalk.gray("• Tokens salida:")}   ${agent.tracker.totalCompletionTokens.toLocaleString()} ($${outputCost.toFixed(5)} USD)` +
+                `\n  ${chalk.gray("• Inversión total:")} ${chalk.bold.green(formattedCost)}\n`);
+            continue;
+        }
+        if (trimmed.startsWith("/effort") || trimmed.startsWith("/espectro") || trimmed === "/model") {
+            const parts = trimmed.split(/\s+/);
+            const targetId = parts[1]?.trim();
+            if (!targetId || !ESPECTRO_MODELS[targetId]) {
+                showEffortMenu(currentModel.id);
+            }
+            else {
+                currentModel = ESPECTRO_MODELS[targetId];
+                const refreshedContext = await getProjectContext(agent.currentCwd);
+                const updatedPrompt = buildSystemPrompt(refreshedContext, currentModel, skillManager, memoryManager, isPlanMode);
+                agent.setEspectroModel(currentModel, updatedPrompt);
+                console.log(chalk.green(`\n✔ Nivel actualizado a `) +
+                    chalk.bold.hex("#A855F7")(currentModel.name) +
+                    chalk.gray(` (${currentModel.effortLevel})`) +
+                    `\n  ${chalk.italic.gray(currentModel.description)}\n`);
+            }
+            continue;
+        }
+        if (trimmed === "/clear") {
+            const refreshedContext = await getProjectContext(agent.currentCwd);
+            systemPrompt = buildSystemPrompt(refreshedContext, currentModel, skillManager, memoryManager, isPlanMode);
+            agent.clearHistory(systemPrompt);
+            resetTypeAhead();
+            console.clear();
+            showBanner(agent.currentCwd, currentModel, "happy");
+            console.log(chalk.green("✔ Historial reiniciado.\n"));
+            continue;
+        }
+        if (trimmed === "/init") {
+            const rulesPath = path.join(agent.currentCwd, RULES_FILE_NAME);
+            if (!fs.existsSync(rulesPath)) {
+                const template = `# 🦊 Reglas del Proyecto (Chocolatito Code)\n\n## 📌 Directivas\n- Lenguaje principal:\n- Framework:\n- Convenciones de código:\n- Pruebas y validación:\n`;
+                fs.writeFileSync(rulesPath, template, "utf-8");
+                console.log(chalk.green(`\n✔ Creado ${RULES_FILE_NAME} en la raíz del proyecto.\n`));
+            }
+            else {
+                console.log(chalk.yellow(`\n⚠ El archivo ${RULES_FILE_NAME} ya existe.\n`));
+            }
+            continue;
+        }
+        // Parse and auto-attach @file mentions
+        const { attachedFiles } = parseFileMentions(trimmed, agent.currentCwd);
+        const enrichedPrompt = buildPromptWithMentions(trimmed, attachedFiles);
+        // Execute task with agent loop
+        await agent.runTask(enrichedPrompt);
+        // Lo que se escribio mientras trabajaba pasa a ser la siguiente orden.
+        pendiente = takeQueued();
+        // Persist session state
+        sessionManager.saveSession({
+            id: sessionId,
+            cwd: agent.currentCwd,
+            modelId: currentModel.id,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            messages: agent.messages,
+        });
+    }
+}
+main().catch((err) => {
+    console.error(chalk.red(`\nError: ${err?.message || String(err)}`));
+    process.exit(1);
+});