chocolatito-code 1.0.0 → 1.2.0

package/dist/agent/loopDetector.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Detector de bucles: el agente repitiendo la misma accion sin avanzar.
+ *
+ * Hasta ahora la unica defensa era el tope de 30 iteraciones del turno. Un
+ * agente atascado —reintentando el mismo edit_file que falla, releyendo el
+ * mismo archivo, relanzando el mismo comando roto— se gastaba las 30 enteras,
+ * con su coste real en la cuota del usuario, antes de que nadie lo parara. Y
+ * como el error que recibia era siempre el mismo texto, nada le empujaba a
+ * cambiar de estrategia.
+ *
+ * Dos decisiones copiadas de opencode y Crush, y las dos importan:
+ *
+ *  1. **Estar atascado no es un error, es una pregunta.** No se aborta el
+ *     turno: se le pregunta al usuario, que es quien sabe si el agente esta
+ *     dando vueltas o esperando algo legitimamente.
+ *
+ *  2. **La firma incluye el RESULTADO, no solo la llamada.** Es lo que separa
+ *     un bucle de un sondeo: leer el mismo log cinco veces mientras cambia es
+ *     trabajo normal; leerlo cinco veces con la misma respuesta byte a byte es
+ *     dar vueltas. Con la firma solo sobre los argumentos, toda paginacion y
+ *     todo polling darian falso positivo.
+ */
+/** Repeticiones identicas seguidas antes de preguntar. */
+export declare const UMBRAL_BUCLE = 3;
+export interface AvisoDeBucle {
+    herramienta: string;
+    repeticiones: number;
+}
+export declare class DetectorDeBucle {
+    private firmas;
+    /** Herramientas para las que el usuario ya dijo "dejalo seguir". */
+    private perdonadas;
+    /**
+     * Apunta una llamada ya ejecutada. Devuelve el aviso si las ultimas
+     * UMBRAL_BUCLE llamadas son identicas entre si.
+     */
+    registrar(herramienta: string, argumentos: string, resultado: string): AvisoDeBucle | null;
+    /**
+     * El usuario dejo seguir. No se vuelve a preguntar por esa herramienta en el
+     * turno: preguntar dos veces por lo mismo es peor que no preguntar.
+     */
+    perdonar(herramienta: string): void;
+    /**
+     * Se corto el bucle. Se olvidan las firmas para que el siguiente aviso exija
+     * tres repeticiones nuevas: si no, cada llamada posterior volveria a
+     * preguntar y el remedio seria peor que el bucle.
+     */
+    olvidar(): void;
+    /** Se llama al empezar cada turno: el usuario ha dicho algo nuevo. */
+    reiniciar(): void;
+}
+/**
+ * Texto que se le devuelve al modelo cuando el usuario corta el bucle. Decirle
+ * "cancelado" a secas le deja sin saber que hacer distinto; esto le nombra el
+ * problema y le da salidas concretas.
+ */
+export declare function mensajeDeBucle(aviso: AvisoDeBucle, indicacion?: string): string;

package/dist/agent/mentions.d.ts

@@ -9,3 +9,16 @@ export declare function parseFileMentions(userInput: string, cwd?: string): {
     attachedFiles: MentionedFile[];
 };
 export declare function buildPromptWithMentions(userInput: string, attachedFiles: MentionedFile[]): string;
+/**
+ * Archivos que el usuario esta nombrando SIN escribir la @.
+ *
+ * La gente no escribe "@src/agent/loop.ts": escribe "el bucle de loop.ts" o
+ * "arregla el fileTracker". Antes eso no lo veia nadie, y el agente empezaba
+ * cada peticion buscando a ciegas un archivo cuyo nombre el usuario acababa de
+ * decir.
+ *
+ * A diferencia de la mencion con @, aqui NO se adjunta el contenido: se dan las
+ * rutas y ya. Pegar tres archivos enteros por si acaso cuesta mas contexto que
+ * la busqueda que ahorra, y el agente sabe leer.
+ */
+export declare function notaDeMencionesImplicitas(userInput: string, cwd?: string, yaAdjuntos?: string[]): string;

package/dist/agent/mentions.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import chalk from "chalk";
+import { extraerMenciones, listarArchivosCacheado, indiceDeDefiniciones } from "./repoMap.js";
 export function parseFileMentions(userInput, cwd = process.cwd()) {
     const mentionRegex = /@([a-zA-Z0-9_\-\.\/\\]+)/g;
     const attachedFiles = [];
@@ -41,3 +42,51 @@ export function buildPromptWithMentions(userInput, attachedFiles) {
         .join("\n");
     return `${userInput}\n${fileBlocks}`;
 }
+/** Archivos que quedan fuera de la nota por no aportar nada al modelo. */
+const MAX_IMPLICITAS = 8;
+/**
+ * Archivos que el usuario esta nombrando SIN escribir la @.
+ *
+ * La gente no escribe "@src/agent/loop.ts": escribe "el bucle de loop.ts" o
+ * "arregla el fileTracker". Antes eso no lo veia nadie, y el agente empezaba
+ * cada peticion buscando a ciegas un archivo cuyo nombre el usuario acababa de
+ * decir.
+ *
+ * A diferencia de la mencion con @, aqui NO se adjunta el contenido: se dan las
+ * rutas y ya. Pegar tres archivos enteros por si acaso cuesta mas contexto que
+ * la busqueda que ahorra, y el agente sabe leer.
+ */
+export function notaDeMencionesImplicitas(userInput, cwd = process.cwd(), yaAdjuntos = []) {
+    let candidatos;
+    try {
+        candidatos = listarArchivosCacheado(cwd);
+    }
+    catch {
+        return "";
+    }
+    if (candidatos.length === 0)
+        return "";
+    const { archivos, identificadores } = extraerMenciones(userInput, candidatos);
+    // Nombrar un simbolo tambien cuenta. Es como habla la gente: "arregla
+    // calcularImpuesto", no "arregla src/facturacion.ts". Un nombre definido en
+    // mas de tres sitios no senala nada, asi que no se ofrece.
+    try {
+        const indice = indiceDeDefiniciones(cwd);
+        for (const ident of identificadores) {
+            if (ident.length < 4)
+                continue;
+            const definidores = indice.get(ident);
+            if (definidores && definidores.length <= 3) {
+                for (const a of definidores)
+                    archivos.add(a);
+            }
+        }
+    }
+    catch { }
+    const adjuntos = new Set(yaAdjuntos.map((a) => a.replace(/\\/g, "/")));
+    const rutas = [...archivos].filter((a) => !adjuntos.has(a.replace(/\\/g, "/"))).slice(0, MAX_IMPLICITAS);
+    if (rutas.length === 0)
+        return "";
+    return (`\n\n[Archivos del proyecto que parece que estas nombrando: ${rutas.join(", ")}. ` +
+        `Son rutas, no contenido: leelas con view_file si te hacen falta.]`);
+}

package/dist/agent/repoMap.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Mapa del repositorio: que hay en el proyecto y que importa de ello.
+ *
+ * Hasta ahora el agente empezaba cada sesion a ciegas. Sabia el tipo de
+ * proyecto y la rama de git (context.ts), y nada mas: para enterarse de que
+ * existe una funcion tenia que buscarla, y para buscarla tenia que sospechar
+ * que existe. El resultado son turnos enteros gastados en grep_search y
+ * list_dir antes de tocar una linea.
+ *
+ * Esto es la version sin tree-sitter del repo map de Aider. Se pierde
+ * precision en la extraccion de simbolos —donde ellos parsean, aqui hay
+ * expresiones regulares por lenguaje— pero las tres piezas que hacen que el
+ * mapa sirva de algo se conservan enteras:
+ *
+ *  1. **Un grafo, no una lista.** Los archivos se puntuan por quien los usa,
+ *     con PageRank. Un fichero de utilidades que importan veinte modulos sale
+ *     antes que uno enorme que no usa nadie.
+ *  2. **El rango del archivo se reparte entre sus simbolos.** Lo que se ensena
+ *     no son ficheros, son definiciones, ordenadas por el "voto" que les mandan
+ *     quienes las llaman.
+ *  3. **Presupuesto de tokens con biseccion.** El mapa se corta al numero de
+ *     simbolos que quepa en el presupuesto, no a un numero fijo de lineas.
+ *
+ * Y lo que sesga todo: lo que el usuario acaba de escribir (ver
+ * extraerMenciones).
+ */
+export interface Simbolo {
+    archivo: string;
+    linea: number;
+    nombre: string;
+    clase: "def" | "ref";
+}
+/**
+ * Patrones de definicion por lenguaje.
+ *
+ * Se prefiere perder alguna definicion a inventarsela: un simbolo fantasma en
+ * el mapa manda al agente a buscar algo que no existe, que es peor que no
+ * mencionarlo.
+ */
+declare const DEFINICIONES: Record<string, RegExp[]>;
+export declare function lenguajeDe(ruta: string): keyof typeof DEFINICIONES | null;
+/**
+ * Definiciones y referencias de un archivo.
+ *
+ * Las referencias son "todo lo que parezca un identificador" menos las
+ * reservadas. Es tosco, pero es exactamente lo que hace Aider cuando la
+ * gramatica de un lenguaje no le da referencias: lo que importa aqui no es
+ * clasificar bien cada token, es saber quien nombra a quien.
+ */
+export interface SimbolosDeArchivo {
+    definiciones: Simbolo[];
+    /**
+     * Cuantas veces se nombra cada identificador. El numero importa: el peso de
+     * la arista lleva una raiz cuadrada encima justo para que un identificador
+     * citado doscientas veces pese mas que uno citado dos, pero no cien veces
+     * mas. Contando solo "aparece o no aparece" esa senal se pierde entera.
+     */
+    referencias: Map<string, number>;
+}
+export declare function extraerSimbolos(ruta: string, contenido: string): SimbolosDeArchivo;
+/**
+ * Un archivo de pruebas es parte del repositorio, pero no es por donde se
+ * empieza a entender un proyecto: nombra a todo el mundo (por eso puntua alto
+ * en el grafo) y no lo llama nadie. Se deja en el mapa, pero al final.
+ */
+export declare function esArchivoDePruebas(ruta: string): boolean;
+export interface Menciones {
+    archivos: Set<string>;
+    identificadores: Set<string>;
+}
+/**
+ * Que archivos e identificadores esta nombrando el usuario.
+ *
+ * Las tres reglas son de Aider y las tres importan:
+ *  - la ruta completa cuenta siempre, normalizando "\" a "/" (en Windows es la
+ *    diferencia entre funcionar y no funcionar);
+ *  - el nombre suelto ("loop.ts") solo cuenta si lleva un separador o un punto
+ *    y si es UNICO en el proyecto, para no confundir "run" o "make";
+ *  - un identificador de 5 letras o mas que coincide con el nombre de un
+ *    archivo lo trae al mapa: escribir "arregla el fileTracker" deberia sacar
+ *    src/agent/fileTracker.ts sin que nadie escriba la ruta.
+ */
+export declare function extraerMenciones(texto: string, archivos: string[]): Menciones;
+/**
+ * PageRank por iteracion de potencia. No hace falta una libreria de grafos:
+ * son veinte lineas y evita una dependencia nativa mas.
+ */
+export declare function pageRank(nodos: string[], aristas: Map<string, {
+    destino: string;
+    peso: number;
+}[]>, personalizacion: Map<string, number>, amortiguacion?: number, vueltas?: number): Map<string, number>;
+export interface OpcionesMapa {
+    cwd: string;
+    /** Texto del usuario, para sesgar el ranking hacia lo que acaba de pedir. */
+    peticion?: string;
+    /** Archivos ya "abiertos" (leidos o editados) en la sesion. */
+    abiertos?: string[];
+    /** Tokens que puede ocupar el mapa. */
+    presupuesto?: number;
+    maxArchivos?: number;
+}
+export declare function listarArchivosCacheado(cwd: string, maxArchivos?: number): string[];
+export declare function indiceDeDefiniciones(cwd: string): Map<string, string[]>;
+export declare function listarArchivos(cwd: string, maxArchivos?: number): string[];
+/**
+ * Construye el mapa. Devuelve el texto listo para inyectar, o "" si no hay
+ * nada que ensenar (proyecto sin codigo reconocible, o presupuesto cero).
+ */
+export declare function construirMapa(opciones: OpcionesMapa): string;
+/**
+ * El bloque tal y como se le entrega al modelo.
+ *
+ * El encabezado no es decorativo: sin el, el modelo trata el mapa como codigo
+ * que acaba de leer y se pone a editar simbolos que solo ha visto de nombre.
+ */
+export declare function bloqueDeMapa(mapa: string): string;
+export {};