chocolatito-code 1.0.0

package/dist/tools/definitions.js

@@ -0,0 +1,401 @@
+import { BROWSER_TOOL, COMPUTER_USE_TOOL, CHROME_TOOL } from "./toolDefsComputer.js";
+import { mcpManager } from "../mcp/manager.js";
+export const TOOLS = [
+    {
+        type: "function",
+        function: {
+            name: "todo_write",
+            description: "Crea o actualiza la lista de tareas del proyecto visible para el usuario (con estado 'pending', 'in_progress' o 'completed').",
+            parameters: {
+                type: "object",
+                properties: {
+                    tasks: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                text: {
+                                    type: "string",
+                                    description: "Descripción de la tarea.",
+                                },
+                                status: {
+                                    type: "string",
+                                    enum: ["pending", "in_progress", "completed"],
+                                    description: "Estado de la tarea.",
+                                },
+                            },
+                            required: ["text", "status"],
+                        },
+                        description: "Lista de tareas estructuradas.",
+                    },
+                },
+                required: ["tasks"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "use_skill",
+            description: "Carga las instrucciones completas y recursos de un skill especializado por su nombre.",
+            parameters: {
+                type: "object",
+                properties: {
+                    skillName: {
+                        type: "string",
+                        description: "El nombre del skill a cargar (ej. 'chocolatito-video', 'artifact-design').",
+                    },
+                },
+                required: ["skillName"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "save_memory",
+            description: "Guarda un hecho importante, preferencia del usuario o aprendizaje en la memoria persistente (~/.chocolatito/memory/).",
+            parameters: {
+                type: "object",
+                properties: {
+                    topic: {
+                        type: "string",
+                        description: "Tema o categoría (ej. 'preferencias_usuario', 'arquitectura_proyecto').",
+                    },
+                    fact: {
+                        type: "string",
+                        description: "El hecho o conocimiento a recordar en futuras sesiones.",
+                    },
+                },
+                required: ["topic", "fact"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "read_memory",
+            description: "Lee un archivo de memoria persistente existente por su tema.",
+            parameters: {
+                type: "object",
+                properties: {
+                    topic: {
+                        type: "string",
+                        description: "El tema o nombre del archivo de memoria a consultar.",
+                    },
+                },
+                required: ["topic"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "spawn_agent",
+            description: "Lanza un subagente autónomo en un contexto aislado para realizar una tarea de búsqueda o planificación sin saturar la memoria principal.",
+            parameters: {
+                type: "object",
+                properties: {
+                    type: {
+                        type: "string",
+                        enum: ["explore", "plan", "general"],
+                        description: "Tipo de subagente: 'explore' (búsqueda e investigación read-only), 'plan' (arquitectura), 'general' (tarea de trabajo).",
+                    },
+                    prompt: {
+                        type: "string",
+                        description: "La instrucción precisa para el subagente.",
+                    },
+                },
+                required: ["type", "prompt"],
+            },
+        },
+    },
+    CHROME_TOOL,
+    BROWSER_TOOL,
+    COMPUTER_USE_TOOL,
+    {
+        type: "function",
+        function: {
+            name: "change_dir",
+            description: "Cambia el directorio de trabajo activo (equivalente a 'cd') con búsqueda profunda automática.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Ruta del directorio al que se desea entrar.",
+                    },
+                },
+                required: ["path"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "find_files",
+            description: "Busca archivos y carpetas por nombre o patrón glob (ej. '*.tsx', 'claude', 'package.json') en cualquier directorio.",
+            parameters: {
+                type: "object",
+                properties: {
+                    pattern: {
+                        type: "string",
+                        description: "Patrón o nombre del archivo o carpeta a buscar.",
+                    },
+                    searchDirectory: {
+                        type: "string",
+                        description: "Directorio base donde buscar.",
+                    },
+                },
+                required: ["pattern"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "view_file",
+            description: "Lee el contenido de un archivo en el disco con numeración de líneas.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Ruta del archivo a leer.",
+                    },
+                    startLine: {
+                        type: "integer",
+                        description: "Línea inicial (opcional).",
+                    },
+                    endLine: {
+                        type: "integer",
+                        description: "Línea final (opcional).",
+                    },
+                },
+                required: ["path"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "edit_file",
+            description: "Reemplaza un bloque CONTIGUO exacto de texto en un archivo existente mostrando diffs.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Ruta del archivo a modificar.",
+                    },
+                    oldText: {
+                        type: "string",
+                        description: "El bloque exacto actual a reemplazar.",
+                    },
+                    newText: {
+                        type: "string",
+                        description: "El nuevo texto que reemplazará a oldText.",
+                    },
+                },
+                required: ["path", "oldText", "newText"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "write_file",
+            description: "Crea un archivo nuevo o sobreescribe uno existente con el contenido provisto.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Ruta del archivo a crear o sobreescribir.",
+                    },
+                    content: {
+                        type: "string",
+                        description: "El contenido completo del archivo.",
+                    },
+                },
+                required: ["path", "content"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "delete_file",
+            description: "Elimina un archivo o directorio de forma segura.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Ruta del archivo o carpeta a eliminar.",
+                    },
+                },
+                required: ["path"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "move_copy_file",
+            description: "Mueve, renombra o copia archivos y directorios.",
+            parameters: {
+                type: "object",
+                properties: {
+                    sourcePath: {
+                        type: "string",
+                        description: "Ruta de origen.",
+                    },
+                    destinationPath: {
+                        type: "string",
+                        description: "Ruta de destino.",
+                    },
+                    operation: {
+                        type: "string",
+                        enum: ["move", "copy"],
+                        description: "Operación a realizar.",
+                    },
+                },
+                required: ["sourcePath", "destinationPath"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "run_command",
+            description: "Ejecuta un comando en la terminal del sistema (PowerShell en Windows, Bash en Unix).",
+            parameters: {
+                type: "object",
+                properties: {
+                    command: {
+                        type: "string",
+                        description: "El comando exacto a ejecutar.",
+                    },
+                    timeout: {
+                        type: "integer",
+                        description: "Tiempo maximo en ms (por defecto 120000, maximo 600000). Subelo para instalaciones, compilaciones o suites de tests largas.",
+                    },
+                },
+                required: ["command"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "list_dir",
+            description: "Lista los archivos y subdirectorios de una carpeta con tamaños.",
+            parameters: {
+                type: "object",
+                properties: {
+                    dirPath: {
+                        type: "string",
+                        description: "Ruta del directorio a listar.",
+                    },
+                },
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "grep_search",
+            description: "Busca un patrón de texto o regex dentro de los archivos del proyecto.",
+            parameters: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "El texto o expresión regular a buscar.",
+                    },
+                    searchPath: {
+                        type: "string",
+                        description: "Ruta donde buscar.",
+                    },
+                },
+                required: ["query"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "web_search",
+            description: "Busca información, documentación o librerías en la web.",
+            parameters: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "El término de búsqueda.",
+                    },
+                },
+                required: ["query"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "web_fetch",
+            description: "Descarga y lee contenido de texto de una URL.",
+            parameters: {
+                type: "object",
+                properties: {
+                    url: {
+                        type: "string",
+                        description: "La URL a consultar.",
+                    },
+                },
+                required: ["url"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "create_image",
+            description: "Genera imágenes o ilustraciones (Python Pillow/Matplotlib o SVG).",
+            parameters: {
+                type: "object",
+                properties: {
+                    outputPath: {
+                        type: "string",
+                        description: "Ruta de salida.",
+                    },
+                    generatorScript: {
+                        type: "string",
+                        description: "Código Python o SVG.",
+                    },
+                },
+                required: ["outputPath", "generatorScript"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "get_system_info",
+            description: "Obtiene diagnóstico del sistema y estado de Git.",
+            parameters: {
+                type: "object",
+                properties: {},
+            },
+        },
+    },
+];
+/**
+ * Herramientas que ve el modelo: las nativas mas las que publiquen los
+ * servidores MCP conectados. Se calcula en cada turno porque un servidor puede
+ * conectarse o caerse a mitad de sesion.
+ */
+export function getAllTools() {
+    const mcp = mcpManager.getToolDefinitions();
+    return mcp.length > 0 ? [...TOOLS, ...mcp] : TOOLS;
+}

package/dist/tools/deleteFile.d.ts

@@ -0,0 +1 @@
+export declare function deleteFile(targetPath: string, cwd?: string): Promise<string>;

package/dist/tools/deleteFile.js

@@ -0,0 +1,17 @@
+import fs from "node:fs";
+import path from "node:path";
+export async function deleteFile(targetPath, cwd = process.cwd()) {
+    const resolved = path.isAbsolute(targetPath) ? targetPath : path.resolve(cwd, targetPath);
+    if (!fs.existsSync(resolved)) {
+        return `Error: La ruta "${targetPath}" no existe.`;
+    }
+    const stat = fs.statSync(resolved);
+    if (stat.isDirectory()) {
+        fs.rmSync(resolved, { recursive: true, force: true });
+        return `✔ Directorio "${targetPath}" y su contenido eliminados exitosamente.`;
+    }
+    else {
+        fs.unlinkSync(resolved);
+        return `✔ Archivo "${targetPath}" eliminado exitosamente.`;
+    }
+}

package/dist/tools/editFile.d.ts

@@ -0,0 +1,5 @@
+export declare function editFile(filePath: string, oldText: string, newText: string, cwd?: string): Promise<{
+    success: boolean;
+    message: string;
+    diffText?: string;
+}>;

package/dist/tools/editFile.js

@@ -0,0 +1,88 @@
+import fs from "node:fs";
+import path from "node:path";
+import { formatNumberedDiff } from "../ui/diffViewer.js";
+export async function editFile(filePath, oldText, newText, cwd = process.cwd()) {
+    const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+    if (!fs.existsSync(resolved)) {
+        return {
+            success: false,
+            message: `Error: El archivo "${filePath}" no existe.`,
+        };
+    }
+    const currentContent = fs.readFileSync(resolved, "utf-8");
+    // Normalize line endings for comparison
+    const normalizedCurrent = currentContent.replace(/\r\n/g, "\n");
+    const normalizedOld = oldText.replace(/\r\n/g, "\n");
+    const normalizedNew = newText.replace(/\r\n/g, "\n");
+    let matchIndex = normalizedCurrent.indexOf(normalizedOld);
+    let finalOldText = normalizedOld;
+    // Si el fragmento aparece varias veces, editar la primera ocurrencia es una
+    // apuesta: puede tocar la funcion equivocada y el usuario no se entera hasta
+    // mucho despues. Mejor negarse y pedir mas contexto.
+    if (matchIndex !== -1 && normalizedOld.length > 0) {
+        let count = 0;
+        let from = 0;
+        while (true) {
+            const at = normalizedCurrent.indexOf(normalizedOld, from);
+            if (at === -1)
+                break;
+            count++;
+            if (count > 1)
+                break;
+            from = at + normalizedOld.length;
+        }
+        if (count > 1) {
+            return {
+                success: false,
+                message: `Error: el fragmento aparece mas de una vez en "${filePath}". No voy a adivinar cual. ` +
+                    `Incluye lineas de alrededor para que el fragmento sea unico.`,
+            };
+        }
+    }
+    // Fallback: If exact match fails, try line-by-line trimmed matching
+    if (matchIndex === -1) {
+        const fileLines = normalizedCurrent.split("\n");
+        const targetLines = normalizedOld.split("\n").map((l) => l.trimEnd());
+        let foundLineIdx = -1;
+        for (let i = 0; i <= fileLines.length - targetLines.length; i++) {
+            let isMatch = true;
+            for (let j = 0; j < targetLines.length; j++) {
+                if (fileLines[i + j].trimEnd() !== targetLines[j]) {
+                    isMatch = false;
+                    break;
+                }
+            }
+            if (isMatch) {
+                if (foundLineIdx === -1) {
+                    foundLineIdx = i;
+                }
+                else {
+                    // Multiple ambiguous matches found, don't guess
+                    foundLineIdx = -2;
+                    break;
+                }
+            }
+        }
+        if (foundLineIdx >= 0) {
+            const matchedBlock = fileLines.slice(foundLineIdx, foundLineIdx + targetLines.length).join("\n");
+            matchIndex = normalizedCurrent.indexOf(matchedBlock);
+            finalOldText = matchedBlock;
+        }
+    }
+    if (matchIndex === -1) {
+        return {
+            success: false,
+            message: `Error: No se encontró el fragmento de texto en "${filePath}". Asegúrate de copiar las líneas exactas a reemplazar.`,
+        };
+    }
+    // Calculate real starting line number in the original file
+    const startLine = normalizedCurrent.slice(0, matchIndex).split("\n").length;
+    const updatedContent = normalizedCurrent.slice(0, matchIndex) + normalizedNew + normalizedCurrent.slice(matchIndex + finalOldText.length);
+    fs.writeFileSync(resolved, updatedContent, "utf-8");
+    const diffText = formatNumberedDiff(path.relative(cwd, resolved) || filePath, finalOldText, normalizedNew, startLine);
+    return {
+        success: true,
+        message: `✔ Archivo "${filePath}" editado exitosamente (Línea ${startLine}+).`,
+        diffText,
+    };
+}

package/dist/tools/findFiles.d.ts

@@ -0,0 +1 @@
+export declare function findFiles(pattern: string, searchDirectory?: string, cwd?: string): Promise<string>;

package/dist/tools/findFiles.js

@@ -0,0 +1,33 @@
+import fs from "node:fs";
+import path from "node:path";
+import fg from "fast-glob";
+export async function findFiles(pattern, searchDirectory = process.cwd(), cwd = process.cwd()) {
+    const resolvedDir = path.isAbsolute(searchDirectory)
+        ? searchDirectory
+        : path.resolve(cwd, searchDirectory);
+    if (!fs.existsSync(resolvedDir)) {
+        return `Error: La carpeta "${searchDirectory}" no existe.`;
+    }
+    const matches = await fg([pattern.includes("*") ? pattern : `**/*${pattern}*`], {
+        cwd: resolvedDir,
+        dot: true,
+        onlyFiles: false,
+        deep: 6,
+        ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/AppData/**", "**/__pycache__/**"],
+    });
+    if (matches.length === 0) {
+        return `No se encontraron archivos ni carpetas con el patrón "${pattern}" en "${resolvedDir}".`;
+    }
+    const formatted = matches.slice(0, 40).map((relPath) => {
+        const full = path.join(resolvedDir, relPath);
+        try {
+            const isDir = fs.statSync(full).isDirectory();
+            return `${isDir ? "[DIR] " : "[FILE]"} ${relPath}`;
+        }
+        catch {
+            return `[ITEM] ${relPath}`;
+        }
+    });
+    const totalStr = matches.length > 40 ? ` (mostrando primeros 40 de ${matches.length})` : "";
+    return `Resultados encontrados para "${pattern}" en "${resolvedDir}"${totalStr}:\n${formatted.join("\n")}`;
+}

package/dist/tools/getSystemInfo.d.ts

@@ -0,0 +1 @@
+export declare function getSystemInfo(cwd?: string): Promise<string>;

package/dist/tools/getSystemInfo.js

@@ -0,0 +1,23 @@
+import os from "node:os";
+import { execa } from "execa";
+export async function getSystemInfo(cwd = process.cwd()) {
+    const nodeVersion = process.version;
+    const platform = `${os.type()} ${os.release()} (${os.arch()})`;
+    const memoryFree = `${(os.freemem() / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+    const memoryTotal = `${(os.totalmem() / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+    let gitInfo = "Git no disponible o fuera de repositorio.";
+    try {
+        const { stdout: status } = await execa("git", ["status", "--short"], { cwd, reject: false });
+        const { stdout: branch } = await execa("git", ["branch", "--show-current"], { cwd, reject: false });
+        gitInfo = `Rama: ${branch.trim() || "HEAD"}\nCambios:\n${status.trim() || "Directorio limpio (sin cambios pendientes)."}`;
+    }
+    catch { }
+    return [
+        `--- INFORMACIÓN DEL SISTEMA ---`,
+        `Plataforma: ${platform}`,
+        `Node.js: ${nodeVersion}`,
+        `Memoria: ${memoryFree} libre de ${memoryTotal}`,
+        `Directorio actual: ${cwd}`,
+        `Estado Git:\n${gitInfo}`,
+    ].join("\n");
+}

package/dist/tools/gitTools.d.ts

@@ -0,0 +1,3 @@
+export declare function gitStatus(cwd?: string): Promise<string>;
+export declare function gitDiff(staged?: boolean, cwd?: string): Promise<string>;
+export declare function gitCommit(message: string, addAll?: boolean, cwd?: string): Promise<string>;

package/dist/tools/gitTools.js

@@ -0,0 +1,47 @@
+import { execa } from "execa";
+export async function gitStatus(cwd = process.cwd()) {
+    try {
+        const { stdout: status } = await execa("git", ["status", "--short"], { cwd, reject: false });
+        const { stdout: branch } = await execa("git", ["branch", "--show-current"], { cwd, reject: false });
+        const { stdout: lastLog } = await execa("git", ["log", "-n", "3", "--oneline"], { cwd, reject: false });
+        return [
+            `--- ESTADO DE GIT ---`,
+            `Rama actual: ${branch.trim() || "HEAD (sin rama)"}`,
+            `Archivos modificados/nuevos:\n${status.trim() || "Repositorio limpio (sin cambios pendientes)."}\n`,
+            `Últimos commits:\n${lastLog.trim() || "Sin historial de commits."}`,
+        ].join("\n");
+    }
+    catch (err) {
+        return `Error consultando estado de Git: ${err?.message || String(err)}`;
+    }
+}
+export async function gitDiff(staged = false, cwd = process.cwd()) {
+    try {
+        const args = ["diff"];
+        if (staged)
+            args.push("--staged");
+        const { stdout } = await execa("git", args, { cwd, reject: false });
+        if (!stdout.trim()) {
+            return staged ? "No hay cambios preparados (staged)." : "No hay cambios sin preparar (unstaged).";
+        }
+        return stdout.slice(0, 12_000);
+    }
+    catch (err) {
+        return `Error obteniendo git diff: ${err?.message || String(err)}`;
+    }
+}
+export async function gitCommit(message, addAll = true, cwd = process.cwd()) {
+    try {
+        if (addAll) {
+            await execa("git", ["add", "-A"], { cwd, reject: false });
+        }
+        const { stdout, stderr, exitCode } = await execa("git", ["commit", "-m", message], { cwd, reject: false });
+        if (exitCode !== 0) {
+            return `Fallo al hacer commit:\n${stderr || stdout}`;
+        }
+        return `✔ Commit creado exitosamente: "${message}"\n${stdout}`;
+    }
+    catch (err) {
+        return `Error creando commit: ${err?.message || String(err)}`;
+    }
+}

package/dist/tools/grepSearch.d.ts

@@ -0,0 +1 @@
+export declare function grepSearch(query: string, searchPath?: string, cwd?: string): Promise<string>;

package/dist/tools/grepSearch.js

@@ -0,0 +1,37 @@
+import fs from "node:fs";
+import path from "node:path";
+import fg from "fast-glob";
+export async function grepSearch(query, searchPath = ".", cwd = process.cwd()) {
+    const resolved = path.isAbsolute(searchPath) ? searchPath : path.resolve(cwd, searchPath);
+    if (!fs.existsSync(resolved)) {
+        return `Error: La ruta "${searchPath}" no existe.`;
+    }
+    const files = await fg(["**/*"], {
+        cwd: resolved,
+        onlyFiles: true,
+        ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/*.lock", "**/*.png", "**/*.jpg", "**/*.mp4", "**/*.webm", "**/*.zip", "**/*.bin"],
+    });
+    const matches = [];
+    const regex = new RegExp(query, "i");
+    for (const relFile of files) {
+        if (matches.length >= 30)
+            break; // Limit to 30 matches
+        const fullPath = path.join(resolved, relFile);
+        try {
+            const content = fs.readFileSync(fullPath, "utf-8");
+            const lines = content.split(/\r?\n/);
+            lines.forEach((line, idx) => {
+                if (regex.test(line) && matches.length < 30) {
+                    matches.push(`${relFile}:${idx + 1} | ${line.trim()}`);
+                }
+            });
+        }
+        catch {
+            // Ignore binary files or read errors
+        }
+    }
+    if (matches.length === 0) {
+        return `No se encontraron coincidencias para "${query}" en "${searchPath}".`;
+    }
+    return `Coincidencias encontradas (${matches.length}):\n${matches.join("\n")}`;
+}

package/dist/tools/listDir.d.ts

@@ -0,0 +1 @@
+export declare function listDir(dirPath?: string, cwd?: string): Promise<string>;