chocolatito-code 1.0.0

package/dist/mcp/client.d.ts

@@ -0,0 +1,55 @@
+export interface McpTool {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, any>;
+}
+export interface McpServerConfig {
+    type?: "stdio" | "http" | "sse" | "streamable-http";
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+}
+/**
+ * Expande ${VAR} y ${VAR:-porDefecto} igual que hace Claude Code, para poder
+ * guardar la configuracion en el repositorio sin meter secretos dentro.
+ */
+export declare function expandVars(value: string): string;
+export declare class McpClient {
+    readonly name: string;
+    tools: McpTool[];
+    lastError: string | null;
+    private config;
+    private proc;
+    private nextId;
+    private pending;
+    private ready;
+    private stderrTail;
+    constructor(name: string, config: McpServerConfig);
+    get transport(): string;
+    get connected(): boolean;
+    connect(timeoutMs?: number): Promise<boolean>;
+    /**
+     * Lanzamiento del servidor en Windows.
+     *
+     * npx, npm, uvx y companyia son scripts .cmd. Node se niega a ejecutarlos
+     * directamente (spawn EINVAL) desde el parche de seguridad de 2024, y la
+     * alternativa comoda, shell:true, concatena los argumentos SIN escaparlos:
+     * un argumento con comillas o & se vuelve inyeccion de comandos.
+     *
+     * La via segura es invocar cmd.exe con los argumentos como lista: Node los
+     * entrecomilla uno a uno en vez de pegarlos en una cadena.
+     */
+    private launchArgs;
+    private spawnServer;
+    private onMessage;
+    private request;
+    private notify;
+    private httpRequest;
+    private initialize;
+    private listTools;
+    callTool(toolName: string, args: Record<string, any>, timeoutMs?: number): Promise<string>;
+    disconnect(): void;
+}

package/dist/mcp/client.js

@@ -0,0 +1,282 @@
+import { spawn } from "node:child_process";
+import readline from "node:readline";
+/**
+ * Cliente del Model Context Protocol.
+ *
+ * MCP es como Claude Code se conecta a herramientas externas: bases de datos,
+ * Figma, Notion, Slack, servidores propios... En vez de programar una
+ * integracion por servicio, se habla un protocolo comun y cualquier servidor MCP
+ * queda disponible como herramientas mas del agente.
+ *
+ * Transporte stdio: JSON-RPC 2.0 delimitado por saltos de linea sobre la entrada
+ * y salida estandar del proceso servidor.
+ */
+const PROTOCOL_VERSION = "2025-06-18";
+/**
+ * Expande ${VAR} y ${VAR:-porDefecto} igual que hace Claude Code, para poder
+ * guardar la configuracion en el repositorio sin meter secretos dentro.
+ */
+export function expandVars(value) {
+    return value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g, (_m, name, fallback) => {
+        const v = process.env[name];
+        if (v !== undefined && v !== "")
+            return v;
+        return fallback ?? "";
+    });
+}
+function expandDeep(value) {
+    if (typeof value === "string")
+        return expandVars(value);
+    if (Array.isArray(value))
+        return value.map(expandDeep);
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(value))
+            out[k] = expandDeep(v);
+        return out;
+    }
+    return value;
+}
+export class McpClient {
+    name;
+    tools = [];
+    lastError = null;
+    config;
+    proc = null;
+    nextId = 1;
+    pending = new Map();
+    ready = false;
+    stderrTail = "";
+    constructor(name, config) {
+        this.name = name;
+        this.config = expandDeep(config);
+    }
+    get transport() {
+        if (this.config.url)
+            return this.config.type || "http";
+        return "stdio";
+    }
+    get connected() {
+        return this.ready;
+    }
+    // ------------------------------------------------------------ conexion
+    async connect(timeoutMs = 20_000) {
+        try {
+            if (this.config.url) {
+                await this.initialize(timeoutMs);
+            }
+            else {
+                if (!this.config.command)
+                    throw new Error("falta 'command' para un servidor stdio");
+                await this.spawnServer();
+                await this.initialize(timeoutMs);
+            }
+            this.tools = await this.listTools(timeoutMs);
+            this.ready = true;
+            return true;
+        }
+        catch (err) {
+            // El stderr del servidor suele explicar mucho mejor el fallo que el
+            // mensaje de la excepcion (falta un paquete, falta una API key...).
+            const extra = this.stderrTail.trim() ? ` — salida del servidor: ${this.stderrTail.trim().slice(-400)}` : "";
+            this.lastError = `${err?.message || String(err)}${extra}`;
+            this.disconnect();
+            return false;
+        }
+    }
+    /**
+     * Lanzamiento del servidor en Windows.
+     *
+     * npx, npm, uvx y companyia son scripts .cmd. Node se niega a ejecutarlos
+     * directamente (spawn EINVAL) desde el parche de seguridad de 2024, y la
+     * alternativa comoda, shell:true, concatena los argumentos SIN escaparlos:
+     * un argumento con comillas o & se vuelve inyeccion de comandos.
+     *
+     * La via segura es invocar cmd.exe con los argumentos como lista: Node los
+     * entrecomilla uno a uno en vez de pegarlos en una cadena.
+     */
+    launchArgs() {
+        const cmd = this.config.command;
+        const args = this.config.args || [];
+        if (process.platform !== "win32")
+            return { exe: cmd, args };
+        const esBinario = /\.exe$/i.test(cmd);
+        if (esBinario)
+            return { exe: cmd, args };
+        const comspec = process.env.ComSpec || "cmd.exe";
+        return { exe: comspec, args: ["/d", "/s", "/c", cmd, ...args] };
+    }
+    async spawnServer() {
+        const { exe, args } = this.launchArgs();
+        const proc = spawn(exe, args, {
+            env: { ...process.env, ...(this.config.env || {}) },
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+            shell: false,
+        });
+        this.proc = proc;
+        const rl = readline.createInterface({ input: proc.stdout });
+        rl.on("line", (line) => this.onMessage(line));
+        proc.stderr.on("data", (d) => {
+            this.stderrTail = (this.stderrTail + d.toString()).slice(-2000);
+        });
+        proc.on("exit", (code) => {
+            this.ready = false;
+            for (const [, p] of this.pending) {
+                clearTimeout(p.timer);
+                p.reject(new Error(`el servidor MCP termino (codigo ${code})`));
+            }
+            this.pending.clear();
+        });
+        proc.on("error", (err) => {
+            this.stderrTail +=
+                err && err.code === "ENOENT"
+                    ? `\nNo se pudo lanzar "${this.config.command}". Comprueba que esta instalado y en el PATH.`
+                    : `\n${err.message}`;
+        });
+    }
+    onMessage(line) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("{"))
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(trimmed);
+        }
+        catch {
+            return;
+        }
+        if (typeof msg.id !== "number")
+            return; // notificacion del servidor
+        const waiter = this.pending.get(msg.id);
+        if (!waiter)
+            return;
+        clearTimeout(waiter.timer);
+        this.pending.delete(msg.id);
+        if (msg.error)
+            waiter.reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+        else
+            waiter.resolve(msg.result);
+    }
+    // ------------------------------------------------------------ JSON-RPC
+    async request(method, params, timeoutMs) {
+        if (this.config.url)
+            return this.httpRequest(method, params, timeoutMs);
+        if (!this.proc || this.proc.killed)
+            throw new Error("el servidor MCP no esta activo");
+        const id = this.nextId++;
+        const payload = JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n";
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`"${method}" no respondio en ${timeoutMs}ms`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            try {
+                this.proc.stdin.write(payload);
+            }
+            catch (err) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(err);
+            }
+        });
+    }
+    notify(method, params) {
+        if (this.config.url || !this.proc)
+            return;
+        try {
+            this.proc.stdin.write(JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n");
+        }
+        catch { }
+    }
+    async httpRequest(method, params, timeoutMs) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const res = await fetch(this.config.url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Accept: "application/json, text/event-stream",
+                    ...(this.config.headers || {}),
+                },
+                body: JSON.stringify({ jsonrpc: "2.0", id: this.nextId++, method, params }),
+                signal: controller.signal,
+            });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            const text = await res.text();
+            // El transporte HTTP puede responder JSON directo o un flujo SSE.
+            const body = text.includes("data:")
+                ? text
+                    .split("\n")
+                    .filter((l) => l.startsWith("data:"))
+                    .map((l) => l.slice(5).trim())
+                    .filter(Boolean)
+                    .pop() || "{}"
+                : text;
+            const parsed = JSON.parse(body);
+            if (parsed.error)
+                throw new Error(parsed.error.message || JSON.stringify(parsed.error));
+            return parsed.result;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    // ------------------------------------------------------------ protocolo
+    async initialize(timeoutMs) {
+        await this.request("initialize", {
+            protocolVersion: PROTOCOL_VERSION,
+            capabilities: { tools: {} },
+            clientInfo: { name: "chocolatito-code", version: "1.0.0" },
+        }, timeoutMs);
+        this.notify("notifications/initialized", {});
+    }
+    async listTools(timeoutMs) {
+        const out = [];
+        let cursor;
+        // Los servidores grandes pagina la lista; sin seguir el cursor se pierden
+        // herramientas en silencio.
+        for (let page = 0; page < 20; page++) {
+            const res = await this.request("tools/list", cursor ? { cursor } : {}, timeoutMs);
+            for (const t of res?.tools || []) {
+                out.push({ name: t.name, description: t.description, inputSchema: t.inputSchema });
+            }
+            cursor = res?.nextCursor;
+            if (!cursor)
+                break;
+        }
+        return out;
+    }
+    async callTool(toolName, args, timeoutMs) {
+        const limit = timeoutMs || this.config.timeout || 120_000;
+        const res = await this.request("tools/call", { name: toolName, arguments: args || {} }, limit);
+        // El resultado viene como una lista de bloques de contenido.
+        const parts = [];
+        for (const c of res?.content || []) {
+            if (c.type === "text")
+                parts.push(c.text);
+            else if (c.type === "image")
+                parts.push(`[imagen ${c.mimeType || "png"} devuelta por la herramienta]`);
+            else if (c.type === "resource")
+                parts.push(c.resource?.text || `[recurso ${c.resource?.uri || ""}]`);
+            else
+                parts.push(`[contenido ${c.type}]`);
+        }
+        const text = parts.join("\n").trim() || "(sin contenido)";
+        return res?.isError ? `El servidor devolvio un error: ${text}` : text;
+    }
+    disconnect() {
+        this.ready = false;
+        if (this.proc && !this.proc.killed) {
+            try {
+                this.proc.stdin.end();
+                this.proc.kill();
+            }
+            catch { }
+        }
+        this.proc = null;
+    }
+}

package/dist/mcp/manager.d.ts

@@ -0,0 +1,26 @@
+import type { ChatCompletionTool } from "openai/resources/chat/completions";
+import { McpServerConfig } from "./client.js";
+export interface McpConfigFile {
+    mcpServers?: Record<string, McpServerConfig>;
+}
+export declare class McpManager {
+    private cwd;
+    private clients;
+    private toolIndex;
+    private loaded;
+    private configPaths;
+    constructor(cwd?: string);
+    readConfig(): Record<string, McpServerConfig>;
+    /** Conecta todos los servidores configurados. Devuelve un resumen legible. */
+    loadAll(timeoutMs?: number): Promise<string>;
+    summary(): string;
+    isMcpTool(name: string): boolean;
+    get toolCount(): number;
+    /** Definiciones en el formato de herramientas que consume el motor. */
+    getToolDefinitions(): ChatCompletionTool[];
+    callTool(fullName: string, args: Record<string, any>): Promise<string>;
+    /** Listado legible para el usuario, al estilo de /mcp. */
+    describe(): string;
+    shutdown(): void;
+}
+export declare const mcpManager: McpManager;

package/dist/mcp/manager.js

@@ -0,0 +1,167 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { McpClient } from "./client.js";
+/**
+ * Gestor de servidores MCP.
+ *
+ * Lee la configuracion con la misma forma que usa Claude Code (.mcp.json con la
+ * clave "mcpServers"), conecta cada servidor y publica sus herramientas al
+ * agente con el nombre convencional mcp__<servidor>__<herramienta>.
+ *
+ * Precedencia, de mas a menos: proyecto -> usuario. Asi un equipo puede versionar
+ * .mcp.json en el repositorio y cada persona anadir los suyos aparte.
+ */
+const MAX_TOOLS_PER_SERVER = 60;
+/** Los nombres de herramienta solo admiten [A-Za-z0-9_-] en la API. */
+function sanitize(name) {
+    return name.replace(/[^A-Za-z0-9_-]/g, "_");
+}
+export class McpManager {
+    cwd;
+    clients = new Map();
+    toolIndex = new Map();
+    loaded = false;
+    configPaths = [];
+    constructor(cwd = process.cwd()) {
+        this.cwd = cwd;
+        this.configPaths = [
+            // Proyecto: se versiona y se comparte con el equipo.
+            path.join(cwd, ".mcp.json"),
+            path.join(cwd, ".chocolatito", "mcp.json"),
+            // Usuario: vale para todos sus proyectos.
+            path.join(os.homedir(), ".chocolatito", "mcp.json"),
+        ];
+    }
+    readConfig() {
+        const merged = {};
+        // Se recorre de menor a mayor prioridad para que el proyecto gane.
+        for (const p of [...this.configPaths].reverse()) {
+            if (!fs.existsSync(p))
+                continue;
+            try {
+                const parsed = JSON.parse(fs.readFileSync(p, "utf-8"));
+                for (const [name, cfg] of Object.entries(parsed.mcpServers || {})) {
+                    merged[name] = cfg;
+                }
+            }
+            catch {
+                // Un JSON roto no debe impedir arrancar el agente.
+            }
+        }
+        return merged;
+    }
+    /** Conecta todos los servidores configurados. Devuelve un resumen legible. */
+    async loadAll(timeoutMs = 20_000) {
+        if (this.loaded)
+            return this.summary();
+        this.loaded = true;
+        const config = this.readConfig();
+        const names = Object.keys(config);
+        if (names.length === 0)
+            return "";
+        // En paralelo: un servidor lento no debe retrasar a los demas.
+        await Promise.all(names.map(async (name) => {
+            const client = new McpClient(name, config[name]);
+            const ok = await client.connect(timeoutMs);
+            this.clients.set(name, client);
+            if (!ok)
+                return;
+            for (const tool of client.tools.slice(0, MAX_TOOLS_PER_SERVER)) {
+                const full = `mcp__${sanitize(name)}__${sanitize(tool.name)}`;
+                this.toolIndex.set(full, { client, toolName: tool.name });
+            }
+        }));
+        return this.summary();
+    }
+    summary() {
+        if (this.clients.size === 0)
+            return "";
+        const lines = [];
+        for (const [name, c] of this.clients) {
+            if (c.connected) {
+                lines.push(`  ✔ ${name} (${c.transport}): ${c.tools.length} herramientas`);
+            }
+            else {
+                lines.push(`  ✖ ${name}: ${c.lastError || "no conectado"}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    isMcpTool(name) {
+        return this.toolIndex.has(name);
+    }
+    get toolCount() {
+        return this.toolIndex.size;
+    }
+    /** Definiciones en el formato de herramientas que consume el motor. */
+    getToolDefinitions() {
+        const out = [];
+        for (const [full, entry] of this.toolIndex) {
+            const meta = entry.client.tools.find((t) => t.name === entry.toolName);
+            const schema = meta?.inputSchema;
+            out.push({
+                type: "function",
+                function: {
+                    name: full,
+                    description: `[MCP · ${entry.client.name}] ${meta?.description || entry.toolName}`.slice(0, 1000),
+                    // Algunos servidores no declaran esquema: hay que dar uno valido igual.
+                    parameters: schema && typeof schema === "object" && schema.type
+                        ? schema
+                        : { type: "object", properties: {} },
+                },
+            });
+        }
+        return out;
+    }
+    async callTool(fullName, args) {
+        const entry = this.toolIndex.get(fullName);
+        if (!entry)
+            return `Error: la herramienta MCP "${fullName}" no esta disponible.`;
+        if (!entry.client.connected) {
+            return `Error: el servidor MCP "${entry.client.name}" no esta conectado (${entry.client.lastError || "?"}).`;
+        }
+        try {
+            return await entry.client.callTool(entry.toolName, args);
+        }
+        catch (err) {
+            return `Error llamando a ${fullName}: ${err?.message || String(err)}`;
+        }
+    }
+    /** Listado legible para el usuario, al estilo de /mcp. */
+    describe() {
+        const config = this.readConfig();
+        if (Object.keys(config).length === 0) {
+            return ("No hay servidores MCP configurados.\n\n" +
+                "Crea un archivo .mcp.json en la raiz del proyecto:\n" +
+                JSON.stringify({
+                    mcpServers: {
+                        "mi-servidor": {
+                            command: "npx",
+                            args: ["-y", "@modelcontextprotocol/server-filesystem", "."],
+                        },
+                    },
+                }, null, 2));
+        }
+        const lines = [`SERVIDORES MCP (${this.clients.size}):`, this.summary(), ""];
+        for (const [name, c] of this.clients) {
+            if (!c.connected || c.tools.length === 0)
+                continue;
+            lines.push(`${name}:`);
+            for (const t of c.tools.slice(0, MAX_TOOLS_PER_SERVER)) {
+                const desc = (t.description || "").split("\n")[0].slice(0, 90);
+                lines.push(`  · mcp__${sanitize(name)}__${sanitize(t.name)} — ${desc}`);
+            }
+            lines.push("");
+        }
+        return lines.join("\n");
+    }
+    shutdown() {
+        for (const [, c] of this.clients)
+            c.disconnect();
+        this.clients.clear();
+        this.toolIndex.clear();
+    }
+}
+export const mcpManager = new McpManager(process.cwd());
+process.on("exit", () => mcpManager.shutdown());

package/dist/memory/manager.d.ts

@@ -0,0 +1,9 @@
+export declare class MemoryManager {
+    private memoryDir;
+    private memoryIndexPath;
+    constructor();
+    private ensureDirectory;
+    getMemoryIndex(): string;
+    saveMemory(topic: string, fact: string): string;
+    readMemory(topic: string): string;
+}

package/dist/memory/manager.js

@@ -0,0 +1,59 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+export class MemoryManager {
+    memoryDir;
+    memoryIndexPath;
+    constructor() {
+        this.memoryDir = path.join(os.homedir(), ".chocolatito", "memory");
+        this.memoryIndexPath = path.join(this.memoryDir, "MEMORY.md");
+        this.ensureDirectory();
+    }
+    ensureDirectory() {
+        if (!fs.existsSync(this.memoryDir)) {
+            fs.mkdirSync(this.memoryDir, { recursive: true });
+        }
+        if (!fs.existsSync(this.memoryIndexPath)) {
+            const defaultIndex = `# 🧠 Memoria Persistente de Chocolatito Code\n\nEste archivo indexa hechos, preferencias del usuario y aprendizajes clave entre proyectos.\n\n- [Preferencias Generales](./preferences.md): Preferencias de desarrollo y estilo.\n`;
+            fs.writeFileSync(this.memoryIndexPath, defaultIndex, "utf-8");
+        }
+    }
+    getMemoryIndex() {
+        this.ensureDirectory();
+        try {
+            return fs.readFileSync(this.memoryIndexPath, "utf-8");
+        }
+        catch {
+            return "Sin memoria previa.";
+        }
+    }
+    saveMemory(topic, fact) {
+        this.ensureDirectory();
+        const sanitized = topic.toLowerCase().replace(/[^a-z0-9_-]/g, "_");
+        const filePath = path.join(this.memoryDir, `${sanitized}.md`);
+        const timestamp = new Date().toISOString().split("T")[0];
+        const entry = `\n- [${timestamp}] ${fact}`;
+        if (fs.existsSync(filePath)) {
+            fs.appendFileSync(filePath, entry, "utf-8");
+        }
+        else {
+            fs.writeFileSync(filePath, `# Memoria: ${topic}\n${entry}\n`, "utf-8");
+        }
+        // Update MEMORY.md index if not already present
+        const indexContent = fs.readFileSync(this.memoryIndexPath, "utf-8");
+        if (!indexContent.includes(`${sanitized}.md`)) {
+            const link = `- [${topic}](./${sanitized}.md): Registro de ${topic}.\n`;
+            fs.appendFileSync(this.memoryIndexPath, link, "utf-8");
+        }
+        return `✔ Hecho guardado en memoria persistente (~/.chocolatito/memory/${sanitized}.md).`;
+    }
+    readMemory(topic) {
+        this.ensureDirectory();
+        const sanitized = topic.toLowerCase().replace(/[^a-z0-9_-]/g, "_");
+        const filePath = path.join(this.memoryDir, `${sanitized}.md`);
+        if (fs.existsSync(filePath)) {
+            return fs.readFileSync(filePath, "utf-8");
+        }
+        return `No hay memoria registrada para el tema "${topic}".`;
+    }
+}

package/dist/prompts/systemPrompt.d.ts

@@ -0,0 +1,5 @@
+import { ProjectContext } from "../agent/context.js";
+import { EspectroModel } from "../config/constants.js";
+import { SkillManager } from "../skills/manager.js";
+import { MemoryManager } from "../memory/manager.js";
+export declare function buildSystemPrompt(context: ProjectContext, model: EspectroModel, skillManager?: SkillManager, memoryManager?: MemoryManager, isPlanMode?: boolean): string;