chocolatito-code 1.6.8 → 1.6.9

package/README.md

@@ -1,4 +1,4 @@
-# 🦊 Chocolatito Code (v1.0.0)
+# 🦊 Chocolatito Code
 
 > **Agente Autónomo de Programación para la Terminal**, desarrollado por **Chocolatito** con la arquitectura del **Motor Espectro**.
 
@@ -278,6 +278,16 @@ Antes de hacer un commit o desplegar cambios, corre `/audit` o `/review`:
 - **Limpieza de depuración:** localiza sentencias residuales como `console.log`, `debugger;` o `print()`.
 - **Sugerencia de Conventional Commits:** genera automáticamente la propuesta de commit semántico según los archivos modificados (ej. `feat(tools): ...`, `test: ...`).
 
+Y se le puede decir dónde callarse. En una herramienta de terminal, `console.log` no es
+un olvido: es la salida del programa. Las rutas que pongas en un `.chocolatitoauditignore`
+—una por línea, `#` para comentar— dejan de salir en la sección de calidad, y el informe
+dice cuántas calló, para que nadie se encuentre el fichero un año después sin saberlo.
+
+**Lo que ese fichero NO puede callar: un secreto.** Una clave, un `.env` o una clave
+privada se avisan siempre, esté la ruta ignorada o no. Una herramienta que se deja
+configurar para callarse una credencial es peor que no tenerla, porque da la
+tranquilidad sin el aviso.
+
 ---
 
 ## 📌 Widget de Tareas en Vivo y Selector /resume

package/dist/tools/gitAudit.d.ts

@@ -19,6 +19,8 @@ export interface AuditReport {
     secrets: AuditFinding[];
     debugLogs: AuditFinding[];
     residualLogs: AuditFinding[];
+    /** Cuantas sentencias se callaron por `.chocolatitoauditignore`. Se dice siempre. */
+    debugSilenciados: number;
     sensitiveFiles: string[];
     suggestedCommit: string;
     rawDiff: string;
@@ -35,7 +37,32 @@ export declare const DEBUG_PATTERNS: Array<{
 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;
+/**
+ * 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;

package/dist/tools/gitAudit.js

@@ -1,3 +1,5 @@
+import fs from "node:fs";
+import path from "node:path";
 import chalk from "chalk";
 import { ejecutarGit } from "./gitTools.js";
 export const SECRET_PATTERNS = [
@@ -16,7 +18,11 @@ export const SENSITIVE_FILE_PATTERN = /(?:^|[/\\])(\.env(?:\.[a-zA-Z0-9_-]+)?|id
 export const DEBUG_PATTERNS = [
     { name: "console.log", pattern: /\bconsole\.log\s*\(/ },
     { name: "console.debug", pattern: /\bconsole\.debug\s*\(/ },
-    { name: "debugger", pattern: /\bdebugger\b/ },
+    // `debugger` como PALABRA sale tambien dentro de una frase: el propio aviso
+    // de esta herramienta dice "ni console.log ni debugger" y se denunciaba solo.
+    // Un `debugger` de verdad es una sentencia: lleva punto y coma, o esta sola en
+    // su linea. Eso es lo que se busca.
+    { name: "debugger", pattern: /(?:^|[;{}])\s*debugger\s*(?:;|$)/ },
     { name: "print()", pattern: /(?<![\w.])print\s*\(/ },
     { name: "var_dump", pattern: /\bvar_dump\s*\(/ },
     { name: "dd()", pattern: /(?<![\w.])dd\s*\(/ },
@@ -60,10 +66,79 @@ export function esDocumentacion(archivo) {
 export function sinCitasEnLinea(texto) {
     return texto.replace(/``[^`]*``/g, " ").replace(/`[^`]*`/g, " ");
 }
-export function auditDiffText(rawDiff, changedFiles = []) {
+/**
+ * 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 const ARCHIVO_DE_IGNORADOS = ".chocolatitoauditignore";
+export function leerPatronesIgnorados(cwd) {
+    try {
+        const crudo = fs.readFileSync(path.join(cwd, ARCHIVO_DE_IGNORADOS), "utf-8");
+        return crudo
+            .split(/\r?\n/)
+            .map((l) => l.trim())
+            .filter((l) => l.length > 0 && !l.startsWith("#"));
+    }
+    catch {
+        return [];
+    }
+}
+/** Un patron de `.chocolatitoauditignore` contra una ruta del diff. */
+export function rutaIgnorada(archivo, patrones) {
+    if (!archivo || patrones.length === 0)
+        return false;
+    const ruta = archivo.replace(/\\/g, "/").replace(/^\.\//, "");
+    const base = ruta.split("/").pop() || ruta;
+    for (const crudo of patrones) {
+        const patron = crudo.replace(/\\/g, "/").replace(/^\.\//, "");
+        // Una carpeta: "src/ui/" tapa todo lo que hay dentro.
+        if (patron.endsWith("/")) {
+            if (ruta.startsWith(patron))
+                return true;
+            continue;
+        }
+        // "**" cruza barras, "*" no: src/*.ts no baja a src/ui/marco.ts, src/**/*.ts si.
+        const comoRegex = patron
+            .split("**")
+            .map((trozo) => trozo
+            .replace(/[.+^$(){}|[\]\\]/g, (m) => "\\" + m)
+            .replace(/\*/g, "[^/]*")
+            .replace(/\?/g, "[^/]"))
+            .join(".*");
+        const re = new RegExp(`^${comoRegex}$`);
+        if (re.test(ruta))
+            return true;
+        // Un patron sin barras ("*.min.js") mira tambien solo el nombre.
+        if (!patron.includes("/") && re.test(base))
+            return true;
+        // Una carpeta escrita sin barra final ("src/ui") tapa igual lo de dentro.
+        if (ruta.startsWith(`${patron}/`))
+            return true;
+    }
+    return false;
+}
+export function auditDiffText(rawDiff, changedFiles = [], patronesIgnorados = []) {
     const secrets = [];
     const debugLogs = [];
     const sensitiveFiles = [];
+    let debugSilenciados = 0;
     for (const f of changedFiles) {
         if (SENSITIVE_FILE_PATTERN.test(f) && !sensitiveFiles.includes(f)) {
             sensitiveFiles.push(f);
@@ -119,9 +194,16 @@ export function auditDiffText(rawDiff, changedFiles = []) {
                     });
                 }
             }
+            const silenciado = rutaIgnorada(currentFile || "", patronesIgnorados);
             for (const dp of DEBUG_PATTERNS) {
                 if (enDocumentacion)
                     break;
+                if (silenciado) {
+                    // Se cuenta aunque no se liste: callar no es esconder.
+                    if (dp.pattern.test(addedContent))
+                        debugSilenciados++;
+                    continue;
+                }
                 if (dp.pattern.test(addedContent)) {
                     debugLogs.push({
                         type: "debug",
@@ -156,6 +238,7 @@ export function auditDiffText(rawDiff, changedFiles = []) {
         secrets,
         debugLogs,
         residualLogs: debugLogs,
+        debugSilenciados,
         sensitiveFiles,
         suggestedCommit,
         rawDiff,
@@ -174,6 +257,7 @@ export async function auditGitDiff(cwd = process.cwd(), mockDiff) {
             secrets: [],
             debugLogs: [],
             residualLogs: [],
+            debugSilenciados: 0,
             sensitiveFiles: [],
             suggestedCommit: "chore: update project",
             rawDiff: statusRes.error,
@@ -188,6 +272,7 @@ export async function auditGitDiff(cwd = process.cwd(), mockDiff) {
             secrets: [],
             debugLogs: [],
             residualLogs: [],
+            debugSilenciados: 0,
             sensitiveFiles: [],
             suggestedCommit: "chore: no pending changes",
             rawDiff: "",
@@ -205,7 +290,7 @@ export async function auditGitDiff(cwd = process.cwd(), mockDiff) {
         diffRes = await ejecutarGit(["diff"], cwd);
     }
     const rawDiff = diffRes.ok ? diffRes.stdout : "";
-    return auditDiffText(rawDiff, changedFiles);
+    return auditDiffText(rawDiff, changedFiles, leerPatronesIgnorados(cwd));
 }
 export function suggestConventionalCommit(files, _insertions, _deletions) {
     if (files.length === 0)
@@ -268,8 +353,15 @@ export function formatAuditReport(report) {
         if (report.debugLogs.length > 5) {
             lines.push(chalk.gray(`    ... y ${report.debugLogs.length - 5} más.`));
         }
+        if (report.debugSilenciados > 0) {
+            lines.push(chalk.gray(`    (${report.debugSilenciados} más en rutas de ${ARCHIVO_DE_IGNORADOS}, sin listar.)`));
+        }
         lines.push("");
     }
+    else if (report.debugSilenciados > 0) {
+        lines.push(chalk.green("  ✔ Calidad: Sin rastros nuevos de console.log ni debugger") +
+            chalk.gray(` (${report.debugSilenciados} en rutas de ${ARCHIVO_DE_IGNORADOS}, sin listar).`));
+    }
     else {
         lines.push(chalk.green("  ✔ Calidad: Sin rastros de console.log ni debugger en líneas nuevas."));
     }

package/extension/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 3,
   "minimum_chrome_version": "102",
   "name": "Chocolatito Code",
-  "version": "1.6.8",
+  "version": "1.6.9",
   "description": "Deja que Chocolatito Code trabaje dentro de tu Chrome, en segundo plano y con tus sesiones ya iniciadas.",
   "permissions": [
     "tabs",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chocolatito-code",
-  "version": "1.6.8",
+  "version": "1.6.9",
   "description": "Agente autónomo de programación para la terminal, con control real del ordenador y del navegador. Desarrollado por Chocolatito.",
   "type": "module",
   "bin": {