chocolatito-code 1.6.7 → 1.6.9

package/dist/tools/browserExtension.js

@@ -799,6 +799,54 @@ export async function chromeExtension(params, cwd = process.cwd(), apiKey) {
                     ? "Trabajo cerrado: pestana desagrupada y aviso retirado."
                     : fail(action, res.error);
             }
+            case "console_logs": {
+                const res = await extensionBridge.send("getConsoleLogs", {
+                    tabId: params.tabId,
+                    clear: params.clear === true,
+                });
+                if (!res.ok)
+                    return fail(action, res.error);
+                const logs = res.data?.logs || [];
+                if (logs.length === 0) {
+                    return "Sin errores de consola registrados en la página.";
+                }
+                const formateados = logs
+                    .map((log) => {
+                    const hora = log.timestamp ? new Date(log.timestamp).toLocaleTimeString() : "";
+                    const nivel = (log.level || "error").toUpperCase();
+                    const prefijo = hora ? `[${hora}] [${nivel}]` : `[${nivel}]`;
+                    let linea = `${prefijo} ${log.message || ""}`;
+                    if (log.url)
+                        linea += ` (${log.url})`;
+                    if (log.stack)
+                        linea += `\n  Stack: ${log.stack.split("\n").slice(0, 3).join("\n  ")}`;
+                    return linea;
+                })
+                    .join("\n");
+                return `LOGS DE CONSOLA (${logs.length} registro${logs.length === 1 ? "" : "s"}):\n${formateados}${params.clear ? "\n(Buffer limpiado)" : ""}`;
+            }
+            case "network_errors": {
+                const res = await extensionBridge.send("getNetworkErrors", {
+                    tabId: params.tabId,
+                    clear: params.clear === true,
+                });
+                if (!res.ok)
+                    return fail(action, res.error);
+                const errors = res.data?.errors || [];
+                if (errors.length === 0) {
+                    return "Sin errores de red registrados en la página.";
+                }
+                const formateados = errors
+                    .map((err) => {
+                    const hora = err.timestamp ? new Date(err.timestamp).toLocaleTimeString() : "";
+                    const status = err.status ? ` HTTP ${err.status}` : "";
+                    const detalle = err.error && err.error !== `HTTP ${err.status}` ? ` - ${err.error}` : "";
+                    const horaStr = hora ? `[${hora}] ` : "";
+                    return `${horaStr}${err.method || "GET"}${status} -> ${err.url}${detalle}`;
+                })
+                    .join("\n");
+                return `ERRORES DE RED (${errors.length} peticion${errors.length === 1 ? "" : "es"} fallida${errors.length === 1 ? "" : "s"}):\n${formateados}${params.clear ? "\n(Buffer limpiado)" : ""}`;
+            }
             default:
                 return fail(String(action), "accion no reconocida.");
         }

package/dist/tools/computerUse.js

@@ -220,10 +220,31 @@ async function estadoTrasActuar(args) {
 export async function computerUse(params, cwd = process.cwd(), apiKey) {
     const { action } = params;
     const mode = params.mode || "background";
-    const targetX = params.coordinate ? params.coordinate[0] : params.x;
-    const targetY = params.coordinate ? params.coordinate[1] : params.y;
-    const startX = params.start_coordinate ? params.start_coordinate[0] : params.x;
-    const startY = params.start_coordinate ? params.start_coordinate[1] : params.y;
+    let targetX = params.coordinate ? params.coordinate[0] : params.x;
+    let targetY = params.coordinate ? params.coordinate[1] : params.y;
+    let startX = params.start_coordinate ? params.start_coordinate[0] : params.x;
+    let startY = params.start_coordinate ? params.start_coordinate[1] : params.y;
+    // Soporte de coordenadas normalizadas (0.0 a 1.0) estilo Astra / OpenAI Operator
+    if (targetX !== undefined && targetY !== undefined && targetX > 0 && targetX <= 1.0 && targetY > 0 && targetY <= 1.0) {
+        try {
+            const sInfo = await winHost.send("screen_info");
+            const sw = sInfo.virtualWidth || sInfo.primaryWidth || 1920;
+            const sh = sInfo.virtualHeight || sInfo.primaryHeight || 1080;
+            targetX = Math.round(targetX * sw);
+            targetY = Math.round(targetY * sh);
+        }
+        catch { }
+    }
+    if (startX !== undefined && startY !== undefined && startX > 0 && startX <= 1.0 && startY > 0 && startY <= 1.0) {
+        try {
+            const sInfo = await winHost.send("screen_info");
+            const sw = sInfo.virtualWidth || sInfo.primaryWidth || 1920;
+            const sh = sInfo.virtualHeight || sInfo.primaryHeight || 1080;
+            startX = Math.round(startX * sw);
+            startY = Math.round(startY * sh);
+        }
+        catch { }
+    }
     try {
         switch (action) {
             // ---------------------------------------------------------------- espera
@@ -459,7 +480,7 @@ export async function computerUse(params, cwd = process.cwd(), apiKey) {
                 if (!apiKey) {
                     return `Sin coincidencias en el arbol de accesibilidad para "${query}", y no hay API key para recurrir a la vision.`;
                 }
-                const shotPath = path.join(ensureCache(), "find_target.png");
+                const shotPath = path.join(ensureCache(), "find_target.jpg");
                 const shot = await captureFor(params, shotPath);
                 if (!shot.ok)
                     return fail(action, shot.error || "no se pudo capturar");
@@ -475,7 +496,7 @@ export async function computerUse(params, cwd = process.cwd(), apiKey) {
             }
             // ---------------------------------------------------------------- captura
             case "screenshot": {
-                const out = resolveOut(params.outputPath, "screen_latest.png", cwd);
+                const out = resolveOut(params.outputPath, "screen_latest.jpg", cwd);
                 const choice = await resolveWindow(params);
                 if (!choice.ok)
                     return fail(action, choice.error);
@@ -502,6 +523,7 @@ export async function computerUse(params, cwd = process.cwd(), apiKey) {
             // ------------------------------------------------------------ raton/teclado
             case "left_click":
             case "click":
+            case "mouse_click":
             case "double_click":
             case "triple_click":
             case "right_click":
@@ -547,7 +569,8 @@ export async function computerUse(params, cwd = process.cwd(), apiKey) {
                     return fail(action, res.error || "fallo desconocido");
                 return `Cursor movido a (${targetX}, ${targetY}).`;
             }
-            case "left_click_drag": {
+            case "left_click_drag":
+            case "drag": {
                 if (targetX === undefined || targetY === undefined || startX === undefined || startY === undefined) {
                     return fail(action, "faltan start_coordinate y coordinate.");
                 }
@@ -589,7 +612,9 @@ export async function computerUse(params, cwd = process.cwd(), apiKey) {
                 return `Escrito en la ventana enfocada (${res.chars} caracteres): "${preview(params.text)}"`;
             }
             case "key":
-            case "hotkey": {
+            case "hotkey":
+            case "press":
+            case "key_press": {
                 const combo = normalizeKeys(params.keys || params.key || params.text || "");
                 if (!combo)
                     return fail(action, 'indica la tecla en "keys" (ej. "Return", "ctrl+t", "alt+Tab").');
@@ -725,7 +750,7 @@ function normalizeKeys(raw) {
     let k = raw.trim();
     if (!k)
         return "";
-    // Restos del formato SendKeys que usaba la version anterior.
+    // Restos del formato SendKeys y alias comunes de Astra/Operator/Playwright
     const sendKeysMap = {
         "{ENTER}": "Return",
         "{ESC}": "Escape",
@@ -740,7 +765,23 @@ function normalizeKeys(raw) {
         "^{TAB}": "ctrl+Tab",
         "%{TAB}": "alt+Tab",
         "%{F4}": "alt+F4",
+        enter: "Return",
+        return: "Return",
+        esc: "Escape",
+        escape: "Escape",
+        tab: "Tab",
+        space: "Space",
+        spacebar: "Space",
+        backspace: "BackSpace",
+        delete: "Delete",
+        del: "Delete",
+        up: "Up",
+        down: "Down",
+        left: "Left",
+        right: "Right",
     };
+    if (sendKeysMap[k.toLowerCase()])
+        return sendKeysMap[k.toLowerCase()];
     if (sendKeysMap[k])
         return sendKeysMap[k];
     if (/^\^\{?[A-Za-z0-9]+\}?$/.test(k))
@@ -749,6 +790,7 @@ function normalizeKeys(raw) {
         k = "alt+" + k.replace(/[%{}]/g, "");
     else if (/^\{[A-Za-z0-9]+\}$/.test(k))
         k = k.slice(1, -1);
+    k = k.replace(/control\+/gi, "ctrl+").replace(/super\+/gi, "win+").replace(/cmd\+/gi, "win+").replace(/meta\+/gi, "win+");
     return k.replace(/\s+/g, "");
 }
 function preview(text) {

package/dist/tools/definitions.js

@@ -54,7 +54,7 @@ export const TOOLS = [
         type: "function",
         function: {
             name: "save_memory",
-            description: "Guarda un hecho importante, preferencia del usuario o aprendizaje en la memoria persistente (~/.chocolatito/memory/).",
+            description: "Guarda un hecho importante, preferencia del usuario o aprendizaje en la memoria persistente (~/.chocolatito/memory/ o local del proyecto).",
             parameters: {
                 type: "object",
                 properties: {
@@ -66,6 +66,11 @@ export const TOOLS = [
                         type: "string",
                         description: "El hecho o conocimiento a recordar en futuras sesiones.",
                     },
+                    scope: {
+                        type: "string",
+                        enum: ["project", "global"],
+                        description: "Ámbito donde guardar: 'project' (local del proyecto en .chocolatito/memory/) o 'global' (en ~/.chocolatito/memory/). Por defecto 'project' si se está en un proyecto válido.",
+                    },
                 },
                 required: ["topic", "fact"],
             },
@@ -83,6 +88,11 @@ export const TOOLS = [
                         type: "string",
                         description: "El tema o nombre del archivo de memoria a consultar.",
                     },
+                    scope: {
+                        type: "string",
+                        enum: ["project", "global"],
+                        description: "Ámbito de consulta: 'project' (local del proyecto) o 'global' (en ~/.chocolatito/memory/). Si no se especifica, busca en proyecto primero y luego en global.",
+                    },
                 },
                 required: ["topic"],
             },
@@ -299,6 +309,88 @@ export const TOOLS = [
             },
         },
     },
+    {
+        type: "function",
+        function: {
+            name: "start_background_task",
+            description: "Inicia un comando en segundo plano sin bloquear el bucle de interacción (útil para servidores dev, watchers, compilaciones continuas).",
+            parameters: {
+                type: "object",
+                properties: {
+                    command: {
+                        type: "string",
+                        description: "El comando a ejecutar en segundo plano.",
+                    },
+                    description: {
+                        type: "string",
+                        description: "Descripción opcional de la tarea.",
+                    },
+                    cwd: {
+                        type: "string",
+                        description: "Directorio de trabajo desde donde ejecutar la tarea (opcional).",
+                    },
+                },
+                required: ["command"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "read_task_output",
+            description: "Lee la salida acumulada (logs) de una tarea en segundo plano sin bloquear.",
+            parameters: {
+                type: "object",
+                properties: {
+                    taskId: {
+                        type: "string",
+                        description: "El ID de la tarea a consultar.",
+                    },
+                    lines: {
+                        type: "integer",
+                        description: "Número de líneas a devolver (por defecto 100).",
+                    },
+                    offset: {
+                        type: "integer",
+                        description: "Línea inicial desde donde comenzar a leer (opcional).",
+                    },
+                },
+                required: ["taskId"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "list_background_tasks",
+            description: "Lista todas las tareas en segundo plano registradas con su estado, PID y tiempo transcurrido.",
+            parameters: {
+                type: "object",
+                properties: {},
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "stop_background_task",
+            description: "Detiene una tarea en segundo plano activa y termina todo su árbol de procesos.",
+            parameters: {
+                type: "object",
+                properties: {
+                    taskId: {
+                        type: "string",
+                        description: "El ID de la tarea a detener.",
+                    },
+                    force: {
+                        type: "boolean",
+                        description: "Si es true, fuerza la terminación inmediata del proceso (por defecto true).",
+                    },
+                },
+                required: ["taskId"],
+            },
+        },
+    },
     {
         type: "function",
         function: {

package/dist/tools/gitAudit.d.ts

@@ -0,0 +1,68 @@
+export interface AuditFinding {
+    type: "secret" | "debug" | "sensitive_file";
+    file: string;
+    line?: number;
+    message: string;
+    snippet?: string;
+}
+export interface AuditStats {
+    filesChanged: number;
+    insertions: number;
+    additions: number;
+    deletions: number;
+    files: string[];
+}
+export interface AuditReport {
+    ok: boolean;
+    clean: boolean;
+    stats: AuditStats;
+    secrets: AuditFinding[];
+    debugLogs: AuditFinding[];
+    residualLogs: AuditFinding[];
+    /** Cuantas sentencias se callaron por `.chocolatitoauditignore`. Se dice siempre. */
+    debugSilenciados: number;
+    sensitiveFiles: string[];
+    suggestedCommit: string;
+    rawDiff: string;
+}
+export declare const SECRET_PATTERNS: Array<{
+    name: string;
+    pattern: RegExp;
+}>;
+export declare const SENSITIVE_FILE_PATTERN: RegExp;
+export declare const DEBUG_PATTERNS: Array<{
+    name: string;
+    pattern: RegExp;
+}>;
+export declare function esDocumentacion(archivo: string): boolean;
+/** Quita los trozos entre comillas invertidas: `asi` y ``asi``. */
+export declare function sinCitasEnLinea(texto: string): string;
+/**
+ * SE PUEDE CALLAR EL RUIDO, NUNCA UN SECRETO
+ *
+ * En un programa de terminal, `console.log` NO es un resto de depuracion: es la
+ * interfaz. Este repositorio tiene ocho en `src/index.ts` que son justo eso -el
+ * enlace de `--servir`, el aviso de que solo escucha en esta maquina- y salian
+ * los ocho en cada auditoria. Ocho avisos que hay que ignorar a mano cada vez
+ * son ocho razones para dejar de leer la seccion entera.
+ *
+ * Adivinar cual es interfaz y cual es un olvido no se puede hacer desde fuera:
+ * es la misma llamada. Asi que lo dice el proyecto, en un `.chocolatitoauditignore`
+ * al lado del `.gitignore`, una ruta o un patron por linea, y `#` para comentar.
+ *
+ * Con un limite que no se negocia: **esto solo calla la seccion de calidad**. Un
+ * secreto, un archivo sensible o una clave privada se avisan siempre, este la
+ * ruta ignorada o no. Una herramienta que se puede configurar para callarse una
+ * credencial es peor que no tenerla, porque da la tranquilidad sin el aviso.
+ *
+ * Y lo que se calla se cuenta: el informe dice cuantos silencio, para que nadie
+ * descubra el fichero un año despues sin saber que estaba puesto.
+ */
+export declare const ARCHIVO_DE_IGNORADOS = ".chocolatitoauditignore";
+export declare function leerPatronesIgnorados(cwd: string): string[];
+/** Un patron de `.chocolatitoauditignore` contra una ruta del diff. */
+export declare function rutaIgnorada(archivo: string, patrones: string[]): boolean;
+export declare function auditDiffText(rawDiff: string, changedFiles?: string[], patronesIgnorados?: string[]): AuditReport;
+export declare function auditGitDiff(cwd?: string, mockDiff?: string): Promise<AuditReport>;
+export declare function suggestConventionalCommit(files: string[], _insertions: number, _deletions: number): string;
+export declare function formatAuditReport(report: AuditReport): string;