chocolatito-code 1.6.6 → 1.6.8

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,41 @@
+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[];
+    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;
+export declare function auditDiffText(rawDiff: string, changedFiles?: 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;

package/dist/tools/gitAudit.js

@@ -0,0 +1,282 @@
+import chalk from "chalk";
+import { ejecutarGit } from "./gitTools.js";
+export const SECRET_PATTERNS = [
+    { name: "Clave de API de OpenAI", pattern: /\bsk-[a-zA-Z0-9]{20,}\b/ },
+    { name: "Clave de API de Anthropic", pattern: /\bsk-ant-[a-zA-Z0-9_-]{20,}\b/ },
+    { name: "Clave de AWS (Access Key)", pattern: /\bAKIA[0-9A-Z]{16}\b/ },
+    { name: "Clave de API de Google", pattern: /\bAIza[0-9A-Za-z\-_]{30,40}\b/ },
+    { name: "Token de acceso de GitHub", pattern: /\bgh[pousr]_[A-Za-z0-9_]{36,}\b/ },
+    { name: "Clave privada (RSA/EC/OpenSSH)", pattern: /-----BEGIN (?:[A-Z ]+)?PRIVATE KEY-----/ },
+    {
+        name: "Asignación genérica de credencial o token",
+        pattern: /(?:secret|password|passwd|api_key|apikey|token|auth_token)\s*[:=]\s*["'][^"'\s]{8,}["']/i,
+    },
+];
+export const SENSITIVE_FILE_PATTERN = /(?:^|[/\\])(\.env(?:\.[a-zA-Z0-9_-]+)?|id_rsa|id_ed25519|.*\.pem)$/i;
+export const DEBUG_PATTERNS = [
+    { name: "console.log", pattern: /\bconsole\.log\s*\(/ },
+    { name: "console.debug", pattern: /\bconsole\.debug\s*\(/ },
+    { name: "debugger", pattern: /\bdebugger\b/ },
+    { name: "print()", pattern: /(?<![\w.])print\s*\(/ },
+    { name: "var_dump", pattern: /\bvar_dump\s*\(/ },
+    { name: "dd()", pattern: /(?<![\w.])dd\s*\(/ },
+];
+/**
+ * LA DOCUMENTACION NO ES CODIGO, Y ESO AQUI IMPORTA
+ *
+ * La primera vez que se paso este auditor por su propio repositorio, se denuncio
+ * a si mismo: la linea del README que dice que detecta `console.log`, `debugger`
+ * y `print()` contiene, por fuerza, un `console.log`, un `debugger` y un
+ * `print()`. Cinco avisos de calidad y una "clave privada" que era la cabecera
+ * `-----BEGIN PRIVATE KEY-----` citada dentro de un parrafo.
+ *
+ * Un auditor que grita en cuanto alguien lo documenta es un auditor que se deja
+ * de leer, y entonces no sirve para lo unico que tiene que servir: que el aviso
+ * de verdad se vea. Asi que:
+ *
+ *  - Las sentencias de depuracion solo se buscan en archivos de codigo. Un
+ *    `console.log` dentro de un .md no es un resto de depuracion: es una frase.
+ *  - En documentacion, lo que va entre comillas invertidas es una cita, no una
+ *    credencial. Se quitan esos trozos ANTES de buscar secretos.
+ *
+ * Lo que NO se toca: una clave de verdad pegada en un README sigue saltando. Una
+ * clave real ocupa mil y pico caracteres y llega en un bloque cercado o a pelo,
+ * nunca dentro de un `span` de una linea, que es lo unico que se ignora.
+ */
+const EXTENSIONES_DE_DOCUMENTACION = new Set([
+    "md",
+    "markdown",
+    "mdx",
+    "txt",
+    "rst",
+    "adoc",
+    "org",
+]);
+export function esDocumentacion(archivo) {
+    const ext = archivo.split(".").pop()?.toLowerCase() || "";
+    return EXTENSIONES_DE_DOCUMENTACION.has(ext);
+}
+/** Quita los trozos entre comillas invertidas: `asi` y ``asi``. */
+export function sinCitasEnLinea(texto) {
+    return texto.replace(/``[^`]*``/g, " ").replace(/`[^`]*`/g, " ");
+}
+export function auditDiffText(rawDiff, changedFiles = []) {
+    const secrets = [];
+    const debugLogs = [];
+    const sensitiveFiles = [];
+    for (const f of changedFiles) {
+        if (SENSITIVE_FILE_PATTERN.test(f) && !sensitiveFiles.includes(f)) {
+            sensitiveFiles.push(f);
+        }
+    }
+    let currentFile = "";
+    let currentLine = 0;
+    let insertions = 0;
+    let deletions = 0;
+    const diffFiles = new Set(changedFiles);
+    const lines = rawDiff.split("\n");
+    for (const line of lines) {
+        if (line.startsWith("diff --git ")) {
+            const parts = line.split(" ");
+            currentFile = parts[parts.length - 1]?.replace(/^b\//, "") || "";
+            if (currentFile)
+                diffFiles.add(currentFile);
+            if (SENSITIVE_FILE_PATTERN.test(currentFile) && !sensitiveFiles.includes(currentFile)) {
+                sensitiveFiles.push(currentFile);
+            }
+            continue;
+        }
+        if (line.startsWith("+++ b/")) {
+            currentFile = line.slice(6).trim();
+            if (currentFile)
+                diffFiles.add(currentFile);
+            if (SENSITIVE_FILE_PATTERN.test(currentFile) && !sensitiveFiles.includes(currentFile)) {
+                sensitiveFiles.push(currentFile);
+            }
+            continue;
+        }
+        if (line.startsWith("@@ ")) {
+            const hunkMatch = line.match(/@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+            if (hunkMatch) {
+                currentLine = parseInt(hunkMatch[1], 10) - 1;
+            }
+            continue;
+        }
+        if (line.startsWith("+") && !line.startsWith("+++")) {
+            insertions++;
+            currentLine++;
+            const addedContent = line.slice(1).trim();
+            const enDocumentacion = esDocumentacion(currentFile || "");
+            const paraSecretos = enDocumentacion ? sinCitasEnLinea(addedContent) : addedContent;
+            for (const sp of SECRET_PATTERNS) {
+                if (sp.pattern.test(paraSecretos)) {
+                    secrets.push({
+                        type: "secret",
+                        file: currentFile || "diff",
+                        line: currentLine,
+                        message: sp.name,
+                        snippet: addedContent.length > 50 ? `${addedContent.slice(0, 47)}…` : addedContent,
+                    });
+                }
+            }
+            for (const dp of DEBUG_PATTERNS) {
+                if (enDocumentacion)
+                    break;
+                if (dp.pattern.test(addedContent)) {
+                    debugLogs.push({
+                        type: "debug",
+                        file: currentFile || "diff",
+                        line: currentLine,
+                        message: dp.name,
+                        snippet: addedContent.length > 50 ? `${addedContent.slice(0, 47)}…` : addedContent,
+                    });
+                }
+            }
+        }
+        else if (line.startsWith("-") && !line.startsWith("---")) {
+            deletions++;
+        }
+        else {
+            currentLine++;
+        }
+    }
+    const allFiles = Array.from(diffFiles);
+    const clean = allFiles.length === 0 && insertions === 0 && deletions === 0 && secrets.length === 0 && sensitiveFiles.length === 0;
+    const suggestedCommit = suggestConventionalCommit(allFiles, insertions, deletions);
+    return {
+        ok: true,
+        clean,
+        stats: {
+            filesChanged: allFiles.length,
+            insertions,
+            additions: insertions,
+            deletions,
+            files: allFiles,
+        },
+        secrets,
+        debugLogs,
+        residualLogs: debugLogs,
+        sensitiveFiles,
+        suggestedCommit,
+        rawDiff,
+    };
+}
+export async function auditGitDiff(cwd = process.cwd(), mockDiff) {
+    if (mockDiff !== undefined) {
+        return auditDiffText(mockDiff);
+    }
+    const statusRes = await ejecutarGit(["status", "--porcelain"], cwd);
+    if (!statusRes.ok) {
+        return {
+            ok: false,
+            clean: true,
+            stats: { filesChanged: 0, insertions: 0, additions: 0, deletions: 0, files: [] },
+            secrets: [],
+            debugLogs: [],
+            residualLogs: [],
+            sensitiveFiles: [],
+            suggestedCommit: "chore: update project",
+            rawDiff: statusRes.error,
+        };
+    }
+    const statusLines = statusRes.stdout.split("\n").filter((l) => l.trim().length > 0);
+    if (statusLines.length === 0) {
+        return {
+            ok: true,
+            clean: true,
+            stats: { filesChanged: 0, insertions: 0, additions: 0, deletions: 0, files: [] },
+            secrets: [],
+            debugLogs: [],
+            residualLogs: [],
+            sensitiveFiles: [],
+            suggestedCommit: "chore: no pending changes",
+            rawDiff: "",
+        };
+    }
+    const changedFiles = [];
+    for (const sl of statusLines) {
+        const filePath = sl.slice(3).trim().replace(/^.*->\s*/, "");
+        if (filePath) {
+            changedFiles.push(filePath);
+        }
+    }
+    let diffRes = await ejecutarGit(["diff", "HEAD"], cwd);
+    if (!diffRes.ok || !diffRes.stdout) {
+        diffRes = await ejecutarGit(["diff"], cwd);
+    }
+    const rawDiff = diffRes.ok ? diffRes.stdout : "";
+    return auditDiffText(rawDiff, changedFiles);
+}
+export function suggestConventionalCommit(files, _insertions, _deletions) {
+    if (files.length === 0)
+        return "chore: no pending changes";
+    const allTests = files.every((f) => f.startsWith("tests/") || f.includes(".test.") || f.includes(".spec."));
+    if (allTests) {
+        const mod = files[0].replace(/^tests\//, "").replace(/\.(test|spec)\.[a-zA-Z0-9]+$/, "");
+        return `test(${mod || "suite"}): add comprehensive test coverage`;
+    }
+    const allDocs = files.every((f) => f.endsWith(".md") || f.startsWith("docs/"));
+    if (allDocs) {
+        return "docs: update documentation and project specifications";
+    }
+    const allTools = files.every((f) => f.includes("tools/") || f.includes("tool"));
+    if (allTools) {
+        return "feat(tools): improve CLI tools and execution workflows";
+    }
+    const allUI = files.every((f) => f.includes("ui/") || f.includes("prompt") || f.includes("pie"));
+    if (allUI) {
+        return "feat(ui): refine interactive terminal interface and widgets";
+    }
+    const hasNewFeature = files.some((f) => f.startsWith("src/"));
+    if (hasNewFeature) {
+        return "feat: enhance core functionality and developer experience";
+    }
+    return "chore: update project files";
+}
+export function formatAuditReport(report) {
+    if (report.clean) {
+        return chalk.green("\n✔ Repositorio limpio. No hay cambios pendientes para auditar.\n");
+    }
+    const lines = [];
+    lines.push(chalk.bold.hex("#D97757")("\n🦊 AUDITORÍA DE CAMBIOS (PRE-COMMIT)"));
+    lines.push(chalk.gray(`  ${report.stats.filesChanged} archivos modificados · ${chalk.green(`+${report.stats.insertions}`)} / ${chalk.red(`-${report.stats.deletions}`)}`));
+    lines.push("");
+    if (report.sensitiveFiles.length > 0 || report.secrets.length > 0) {
+        lines.push(chalk.bold.red("  🚨 ADVERTENCIA DE SEGURIDAD:"));
+        for (const sf of report.sensitiveFiles) {
+            lines.push(chalk.red(`    ✖ Archivo sensible detectado: `) + chalk.bold.white(sf));
+        }
+        for (const s of report.secrets) {
+            const loc = s.line ? `:${s.line}` : "";
+            lines.push(chalk.red(`    ✖ [${s.message}] en `) +
+                chalk.bold.white(`${s.file}${loc}`) +
+                chalk.gray(`: "${s.snippet || ""}"`));
+        }
+        lines.push("");
+    }
+    else {
+        lines.push(chalk.green("  ✔ Seguridad: Sin credenciales ni claves de API expuestas en el diff."));
+    }
+    if (report.debugLogs.length > 0) {
+        lines.push(chalk.yellow(`  ⚠ Calidad de código: ${report.debugLogs.length} sentencias de depuración encontradas:`));
+        for (const d of report.debugLogs.slice(0, 5)) {
+            const loc = d.line ? `:${d.line}` : "";
+            lines.push(chalk.gray(`    • [${d.message}] en `) +
+                chalk.white(`${d.file}${loc}`) +
+                chalk.gray(`: "${d.snippet || ""}"`));
+        }
+        if (report.debugLogs.length > 5) {
+            lines.push(chalk.gray(`    ... y ${report.debugLogs.length - 5} más.`));
+        }
+        lines.push("");
+    }
+    else {
+        lines.push(chalk.green("  ✔ Calidad: Sin rastros de console.log ni debugger en líneas nuevas."));
+    }
+    lines.push("");
+    lines.push(chalk.bold.hex("#A855F7")("  💡 Sugerencia de Commit Semántico (Conventional Commits):"));
+    lines.push(`     ${chalk.bold.white(report.suggestedCommit)}`);
+    lines.push(chalk.gray(`     (Usa: /commit "${report.suggestedCommit}")`));
+    lines.push("");
+    return lines.join("\n");
+}

package/dist/tools/runCommand.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { esWindows, shellPosix } from "../config/plataforma.js";
 import { StringDecoder } from "node:string_decoder";
 /**
  * Ejecucion de comandos de shell.
@@ -108,9 +109,11 @@ export async function runCommand(command, cwd = process.cwd(), timeoutMs) {
         return "Aviso: para esperar, usa 'computer_use' con action 'wait' y ms, en vez de bloquear un shell.";
     }
     const timeout = Math.min(Math.max(timeoutMs || DEFAULT_TIMEOUT_MS, 1_000), MAX_TIMEOUT_MS);
-    const isWindows = process.platform === "win32";
+    const isWindows = esWindows;
     // Se usa de verdad el shell que toca. En Windows, PowerShell.
-    const shellPath = isWindows ? "powershell.exe" : "/bin/bash";
+    // En Unix no se pone "/bin/bash" a pelo: en Termux ese archivo no existe y
+    // fallarian todos los comandos, no solo alguno. Ver config/plataforma.
+    const shellPath = isWindows ? "powershell.exe" : shellPosix("bash");
     const shellArgs = isWindows
         ? // -NoProfile para que el perfil del usuario no ensucie la salida ni cueste
             // medio segundo, y -NonInteractive para que cualquier prompt sea un error