chocolatito-code 1.0.0

package/dist/tools/viewFile.d.ts

@@ -0,0 +1 @@
+export declare function viewFile(filePath: string, startLine?: number, endLine?: number, cwd?: string): Promise<string>;

package/dist/tools/viewFile.js

@@ -0,0 +1,45 @@
+import fs from "node:fs";
+import path from "node:path";
+export async function viewFile(filePath, startLine, endLine, cwd = process.cwd()) {
+    const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+    if (!fs.existsSync(resolved)) {
+        return `Error: El archivo "${filePath}" no existe.`;
+    }
+    const stat = fs.statSync(resolved);
+    if (stat.isDirectory()) {
+        return `Error: "${filePath}" es un directorio, usa list_dir en su lugar.`;
+    }
+    const BINARY_EXTENSIONS = new Set([
+        ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".svgz",
+        ".zip", ".tar", ".gz", ".7z", ".rar",
+        ".pdf", ".exe", ".dll", ".so", ".dylib", ".bin",
+        ".mp4", ".mov", ".avi", ".mkv", ".mp3", ".wav",
+        ".woff", ".woff2", ".ttf", ".eot"
+    ]);
+    const ext = path.extname(resolved).toLowerCase();
+    if (BINARY_EXTENSIONS.has(ext)) {
+        return `Aviso: "${filePath}" es un archivo binario (${ext.slice(1).toUpperCase()}) y no contiene texto plano legible. No intentes leerlo como texto.`;
+    }
+    const content = fs.readFileSync(resolved, "utf-8");
+    const lines = content.split(/\r?\n/);
+    const totalLines = lines.length;
+    const isUnbounded = !startLine && !endLine;
+    const maxInitialLines = 400;
+    let sLine = Math.max(1, startLine || 1);
+    let eLine = Math.min(totalLines, endLine || (isUnbounded && totalLines > maxInitialLines ? maxInitialLines : totalLines));
+    if (sLine > totalLines) {
+        return `Error: startLine (${sLine}) supera el total de líneas (${totalLines}).`;
+    }
+    const sliced = lines.slice(sLine - 1, eLine);
+    const numbered = sliced.map((line, idx) => {
+        const lineNum = sLine + idx;
+        return `${lineNum.toString().padStart(4, " ")} | ${line}`;
+    });
+    const overflowNotice = isUnbounded && totalLines > maxInitialLines
+        ? `\n\n[... Archivo extenso: mostrando primeras ${maxInitialLines} de ${totalLines} líneas. Especifica startLine y endLine para inspeccionar el resto ...]`
+        : "";
+    return [
+        `--- Archivo: ${path.relative(cwd, resolved)} (Líneas ${sLine}-${eLine} de ${totalLines}) ---`,
+        numbered.join("\n") + overflowNotice,
+    ].join("\n");
+}

package/dist/tools/visionBridge.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Puente de vision.
+ *
+ * El modelo principal del bucle (deepseek-v4-flash / -pro) es de texto: una
+ * captura de pantalla no le dice absolutamente nada. Antes el agente tomaba la
+ * foto, recibia "captura guardada, 340 KB" y a partir de ahi hacia clic en
+ * coordenadas inventadas. De ahi que "siempre abriera lo que no es".
+ *
+ * Aqui la captura se manda a un modelo multimodal (deepseek-v4-flash-vision-exp)
+ * que devuelve TEXTO: o una descripcion de lo que hay en pantalla, o las
+ * coordenadas del elemento buscado. Ese texto si lo entiende el bucle principal.
+ */
+export interface VisionResult {
+    ok: boolean;
+    text?: string;
+    error?: string;
+    usage?: {
+        prompt: number;
+        completion: number;
+    };
+}
+/** Describe lo que se ve, orientado a decidir el siguiente paso. */
+export declare function describeScreen(apiKey: string, imagePath: string, question?: string): Promise<VisionResult>;
+export interface LocateResult {
+    ok: boolean;
+    x?: number;
+    y?: number;
+    found?: boolean;
+    reason?: string;
+    error?: string;
+}
+/**
+ * Localiza un elemento y devuelve su centro EN PIXELES DE LA IMAGEN.
+ * La conversion a coordenadas de pantalla la hace quien llama, que es el unico
+ * que conoce el factor de escala y el origen de la captura.
+ */
+export declare function locateElement(apiKey: string, imagePath: string, target: string, imageWidth: number, imageHeight: number): Promise<LocateResult>;

package/dist/tools/visionBridge.js

@@ -0,0 +1,107 @@
+import fs from "node:fs";
+import { VISION_MODEL } from "../config/constants.js";
+import { createEngineClient } from "../config/engine.js";
+function client(apiKey) {
+    return createEngineClient(apiKey, "vision");
+}
+function toDataUrl(imagePath) {
+    const buf = fs.readFileSync(imagePath);
+    return `data:image/png;base64,${buf.toString("base64")}`;
+}
+async function ask(apiKey, prompt, imagePath, maxTokens) {
+    if (!apiKey)
+        return { ok: false, error: "No hay API key disponible para el modelo de vision." };
+    if (!fs.existsSync(imagePath))
+        return { ok: false, error: `No existe la imagen "${imagePath}".` };
+    try {
+        const res = await client(apiKey).chat.completions.create({
+            model: VISION_MODEL,
+            max_tokens: maxTokens,
+            temperature: 0,
+            messages: [
+                {
+                    role: "user",
+                    content: [
+                        { type: "text", text: prompt },
+                        { type: "image_url", image_url: { url: toDataUrl(imagePath) } },
+                    ],
+                },
+            ],
+        });
+        const msg = res.choices[0]?.message;
+        // El modelo de vision razona antes de responder. Si el presupuesto de tokens
+        // se agota razonando, 'content' llega vacio y el agente se queda sin ojos sin
+        // enterarse: en ese caso se aprovecha el razonamiento como respuesta.
+        let text = (msg?.content || "").trim();
+        if (!text && typeof msg?.reasoning_content === "string") {
+            text = msg.reasoning_content.trim();
+        }
+        if (!text) {
+            return { ok: false, error: "el modelo de vision no devolvio texto (presupuesto de tokens agotado)." };
+        }
+        if (res.choices[0]?.finish_reason === "length") {
+            text += "\n[La descripcion se corto por longitud; pregunta algo mas concreto si necesitas mas detalle.]";
+        }
+        return {
+            ok: true,
+            text,
+            usage: {
+                prompt: res.usage?.prompt_tokens || 0,
+                completion: res.usage?.completion_tokens || 0,
+            },
+        };
+    }
+    catch (err) {
+        return { ok: false, error: `Fallo el modelo de vision: ${err?.message || String(err)}` };
+    }
+}
+/** Describe lo que se ve, orientado a decidir el siguiente paso. */
+export async function describeScreen(apiKey, imagePath, question) {
+    const q = question && question.trim().length > 0 ? question.trim() : "Describe el estado actual de la pantalla.";
+    const prompt = `Eres los ojos de un agente que controla este ordenador. Observa la captura y responde en espanol, ` +
+        `de forma concreta y sin adornos.\n\n` +
+        `Pregunta: ${q}\n\n` +
+        `Incluye siempre: que aplicacion y que pantalla concreta se ve, que elementos accionables hay ` +
+        `(botones, campos, pestanas) con su texto exacto, y si hay dialogos, errores o cargas en curso. ` +
+        `Si algo esta a medio cargar, dilo explicitamente. No inventes elementos que no aparezcan.\n` +
+        `Se breve: como mucho 12 lineas. Nada de preambulos.`;
+    return ask(apiKey, prompt, imagePath, 1600);
+}
+/**
+ * Localiza un elemento y devuelve su centro EN PIXELES DE LA IMAGEN.
+ * La conversion a coordenadas de pantalla la hace quien llama, que es el unico
+ * que conoce el factor de escala y el origen de la captura.
+ */
+export async function locateElement(apiKey, imagePath, target, imageWidth, imageHeight) {
+    const prompt = `Observa la captura de pantalla, de ${imageWidth} x ${imageHeight} pixeles.\n\n` +
+        `Localiza este elemento: "${target}"\n\n` +
+        `Responde UNICAMENTE con un objeto JSON, sin texto alrededor y sin bloques de codigo:\n` +
+        `{"found": true, "x": <centro horizontal en pixeles>, "y": <centro vertical en pixeles>, "reason": "<que viste>"}\n` +
+        `Si el elemento no aparece en la captura, responde {"found": false, "x": 0, "y": 0, "reason": "<por que>"}.\n` +
+        `El origen (0,0) es la esquina superior izquierda de la imagen. No inventes: si dudas, found=false.`;
+    const res = await ask(apiKey, prompt, imagePath, 900);
+    if (!res.ok)
+        return { ok: false, error: res.error };
+    const raw = (res.text || "").replace(/```json/gi, "").replace(/```/g, "").trim();
+    const match = raw.match(/\{[\s\S]*\}/);
+    if (!match)
+        return { ok: false, error: `El modelo de vision no devolvio JSON: ${raw.slice(0, 200)}` };
+    try {
+        const parsed = JSON.parse(match[0]);
+        const x = Math.round(Number(parsed.x));
+        const y = Math.round(Number(parsed.y));
+        const found = parsed.found === true && Number.isFinite(x) && Number.isFinite(y);
+        // Un punto fuera de la imagen es una alucinacion, no un acierto.
+        const inside = x >= 0 && y >= 0 && x <= imageWidth && y <= imageHeight;
+        return {
+            ok: true,
+            found: found && inside,
+            x,
+            y,
+            reason: typeof parsed.reason === "string" ? parsed.reason : "",
+        };
+    }
+    catch (err) {
+        return { ok: false, error: `JSON invalido del modelo de vision: ${err?.message || String(err)}` };
+    }
+}

package/dist/tools/webFetch.d.ts

@@ -0,0 +1 @@
+export declare function webFetch(url: string): Promise<string>;

package/dist/tools/webFetch.js

@@ -0,0 +1,25 @@
+export async function webFetch(url) {
+    try {
+        const res = await fetch(url, {
+            headers: {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) ChocolatitoCode/1.0",
+            },
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!res.ok) {
+            return `Error HTTP ${res.status}: ${res.statusText} al consultar ${url}`;
+        }
+        const text = await res.text();
+        // Clean basic html tags for readability
+        const stripped = text
+            .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "")
+            .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, "")
+            .replace(/<[^>]+>/g, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+        return stripped.slice(0, 8_000) || "Página web leída pero sin contenido de texto.";
+    }
+    catch (err) {
+        return `Error al consultar URL "${url}": ${err?.message || String(err)}`;
+    }
+}

package/dist/tools/webSearch.d.ts

@@ -0,0 +1 @@
+export declare function webSearch(query: string): Promise<string>;

package/dist/tools/webSearch.js

@@ -0,0 +1,35 @@
+export async function webSearch(query) {
+    try {
+        const encoded = encodeURIComponent(query);
+        const url = `https://html.duckduckgo.com/html/?q=${encoded}`;
+        const res = await fetch(url, {
+            headers: {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+            },
+            signal: AbortSignal.timeout(12_000),
+        });
+        if (!res.ok) {
+            return `Error al buscar en la web: HTTP ${res.status}`;
+        }
+        const html = await res.text();
+        // Parse results from DuckDuckGo HTML
+        const results = [];
+        const regex = /<a class="result__url"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g;
+        let match;
+        let count = 0;
+        while ((match = regex.exec(html)) !== null && count < 6) {
+            count++;
+            const link = match[1].trim();
+            const title = match[2].replace(/<[^>]+>/g, "").trim();
+            const snippet = match[3].replace(/<[^>]+>/g, "").trim();
+            results.push(`[${count}] ${title}\n    URL: ${link}\n    ${snippet}`);
+        }
+        if (results.length === 0) {
+            return `No se encontraron resultados directos para "${query}".`;
+        }
+        return `Resultados de búsqueda web para "${query}":\n\n${results.join("\n\n")}`;
+    }
+    catch (err) {
+        return `Error en búsqueda web: ${err?.message || String(err)}`;
+    }
+}

package/dist/tools/win/hostClient.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Cliente del host persistente de Windows.
+ *
+ * La version anterior lanzaba un powershell.exe nuevo por cada accion y volvia a
+ * compilar los tipos nativos con Add-Type cada vez (~700-1500ms por clic). Con 15
+ * acciones seguidas eso son 20 segundos de nada, y es lo que hacia que el agente
+ * pareciera "trabado".
+ *
+ * Aqui se arranca UN solo proceso, se compila una vez, y despues cada accion
+ * cuesta unos pocos milisegundos por stdin/stdout.
+ */
+export interface HostResponse {
+    ok?: boolean;
+    error?: string;
+    [key: string]: any;
+}
+declare class WinHost {
+    private proc;
+    private ready;
+    private nextId;
+    private pending;
+    private scriptPath;
+    private lastError;
+    constructor();
+    isWindows(): boolean;
+    private start;
+    send(action: string, args?: Record<string, any>, timeoutMs?: number): Promise<HostResponse>;
+    shutdown(): void;
+}
+export declare const winHost: WinHost;
+export {};

package/dist/tools/win/hostClient.js

@@ -0,0 +1,158 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import crypto from "node:crypto";
+import readline from "node:readline";
+import { spawn } from "node:child_process";
+import { WIN_HOST_SCRIPT } from "./hostScript.js";
+const READY_TIMEOUT_MS = 60_000;
+const DEFAULT_TIMEOUT_MS = 30_000;
+class WinHost {
+    proc = null;
+    ready = null;
+    nextId = 1;
+    pending = new Map();
+    scriptPath;
+    lastError = null;
+    constructor() {
+        const dir = path.join(os.homedir(), ".chocolatito");
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        // El nombre lleva el hash del script: si se actualiza el codigo del host, se
+        // escribe un fichero nuevo y no queda una version vieja cacheada.
+        const hash = crypto.createHash("sha1").update(WIN_HOST_SCRIPT).digest("hex").slice(0, 10);
+        this.scriptPath = path.join(dir, `win-host-${hash}.ps1`);
+        if (!fs.existsSync(this.scriptPath)) {
+            fs.writeFileSync(this.scriptPath, WIN_HOST_SCRIPT, "utf-8");
+        }
+    }
+    isWindows() {
+        return process.platform === "win32";
+    }
+    start() {
+        if (this.ready)
+            return this.ready;
+        this.ready = new Promise((resolve, reject) => {
+            let settled = false;
+            const proc = spawn("powershell.exe", ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", this.scriptPath], { windowsHide: true, stdio: ["pipe", "pipe", "pipe"] });
+            this.proc = proc;
+            const bootTimer = setTimeout(() => {
+                if (!settled) {
+                    settled = true;
+                    reject(new Error("El host de Windows no arranco en 60s."));
+                }
+            }, READY_TIMEOUT_MS);
+            const rl = readline.createInterface({ input: proc.stdout });
+            rl.on("line", (line) => {
+                const trimmed = line.trim();
+                if (!trimmed.startsWith("CHOCO#"))
+                    return;
+                const sep = trimmed.indexOf("#", 6);
+                if (sep < 0)
+                    return;
+                const id = parseInt(trimmed.slice(6, sep), 10);
+                let payload;
+                try {
+                    payload = JSON.parse(trimmed.slice(sep + 1));
+                }
+                catch {
+                    payload = { ok: false, error: `respuesta ilegible del host: ${trimmed.slice(sep + 1, sep + 200)}` };
+                }
+                if (id === 0) {
+                    clearTimeout(bootTimer);
+                    if (!settled) {
+                        settled = true;
+                        resolve();
+                    }
+                    return;
+                }
+                const waiter = this.pending.get(id);
+                if (waiter) {
+                    clearTimeout(waiter.timer);
+                    this.pending.delete(id);
+                    waiter.resolve(payload);
+                }
+            });
+            let stderrBuf = "";
+            proc.stderr.on("data", (d) => {
+                stderrBuf += d.toString();
+                if (stderrBuf.length > 4000)
+                    stderrBuf = stderrBuf.slice(-4000);
+                this.lastError = stderrBuf;
+            });
+            proc.on("error", (err) => {
+                clearTimeout(bootTimer);
+                if (!settled) {
+                    settled = true;
+                    reject(err);
+                }
+            });
+            proc.on("exit", (code) => {
+                clearTimeout(bootTimer);
+                // Si el host muere, se libera a los que esperan y se marca para reinicio.
+                for (const [, waiter] of this.pending) {
+                    clearTimeout(waiter.timer);
+                    waiter.resolve({ ok: false, error: `El host de Windows termino (codigo ${code}). ${stderrBuf.slice(0, 500)}` });
+                }
+                this.pending.clear();
+                this.proc = null;
+                this.ready = null;
+                if (!settled) {
+                    settled = true;
+                    reject(new Error(`El host de Windows no pudo iniciar: ${stderrBuf.slice(0, 800) || `codigo ${code}`}`));
+                }
+            });
+        });
+        return this.ready;
+    }
+    async send(action, args = {}, timeoutMs = DEFAULT_TIMEOUT_MS) {
+        if (!this.isWindows()) {
+            return { ok: false, error: "computer_use nativo solo esta implementado para Windows." };
+        }
+        try {
+            await this.start();
+        }
+        catch (err) {
+            return { ok: false, error: `No se pudo iniciar el host de Windows: ${err?.message || String(err)}` };
+        }
+        const proc = this.proc;
+        if (!proc || proc.killed) {
+            return { ok: false, error: "El host de Windows no esta disponible." };
+        }
+        const id = this.nextId++;
+        const payload = JSON.stringify({ id, action, ...args });
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                resolve({ ok: false, error: `La accion "${action}" supero el tiempo limite de ${timeoutMs}ms.` });
+            }, timeoutMs);
+            this.pending.set(id, { resolve, timer });
+            try {
+                proc.stdin.write(payload + "\n");
+            }
+            catch (err) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                resolve({ ok: false, error: `No se pudo escribir al host: ${err?.message || String(err)}` });
+            }
+        });
+    }
+    shutdown() {
+        if (this.proc && !this.proc.killed) {
+            try {
+                this.proc.stdin.end();
+                this.proc.kill();
+            }
+            catch { }
+        }
+        this.proc = null;
+        this.ready = null;
+    }
+}
+export const winHost = new WinHost();
+// Al cerrar la CLI no dejamos un powershell.exe huerfano de fondo.
+process.on("exit", () => winHost.shutdown());
+process.on("SIGINT", () => {
+    winHost.shutdown();
+    process.exit(0);
+});

package/dist/tools/win/hostScript.d.ts

@@ -0,0 +1 @@
+export declare const WIN_HOST_SCRIPT: string;