chocolatito-code 1.3.0 → 1.3.2

package/dist/agent/loop.js

@@ -3,7 +3,7 @@ import process from "node:process";
 import { getAllTools } from "../tools/definitions.js";
 import { executeToolCall } from "../tools/runner.js";
 import { TokenTracker } from "./tracker.js";
-import { renderToolStart, renderToolSuccess, renderToolError, renderDiff, renderFooter, renderError, } from "../ui/renderer.js";
+import { renderToolStart, renderToolSuccess, renderToolError, renderDiff, renderFooter, renderError, formatToolName, } from "../ui/renderer.js";
 import { CONTEXT_WINDOW, MAX_OUTPUT_TOKENS, COMPACT_THRESHOLD_TOKENS, } from "../config/constants.js";
 import { withRetry, isContextOverflow, esDemasiadasEnCurso } from "./retry.js";
 import { canRunInParallel } from "../tools/safety.js";
@@ -14,7 +14,7 @@ import { checkQuota, recordUsage, mensajeDeCorte, quotaBadge } from "../config/q
 import { ReasoningStream } from "../ui/reasoningStream.js";
 import { PermissionManager, commandSignature, isDangerousCommand } from "../config/permissions.js";
 import { askToolPermission } from "../ui/permissionPrompt.js";
-import { DynamicSpinner } from "../ui/spinner.js";
+import { DynamicSpinner, conSpinner } from "../ui/spinner.js";
 import { globalUndoManager } from "./undoManager.js";
 import { salida } from "./salidaDelAgente.js";
 import { InterruptWatcher, isAbortError } from "../ui/interrupt.js";
@@ -727,7 +727,20 @@ export class AgentLoop {
             // huecos de la licencia durante minutos, y los cortes vienen en rachas:
             // reintentar es justo como se pasa de perder un hueco a perder los cuatro.
             // Mas vale que el usuario reescriba una linea.
-            if (!llegoElFinal && (content.trim().length > 0 || toolCalls.length > 0)) {
+            //
+            // NO SE EXIGE QUE HAYA LLEGADO TEXTO. La primera version pedia contenido o
+            // herramientas, y se le escapaba el caso mas comun: el corte que pasa
+            // DESPUES del razonamiento y ANTES de la primera palabra. Eso caia en la
+            // rama de "respuesta vacia", que si reintenta, y volvia a gastar huecos:
+            //
+            //     💭 penso 2s
+            //     ⚠ El motor no devolvio nada. Reintentando una vez…
+            //
+            // Sin marca de final, el stream se corto. Da igual cuanto habia llegado.
+            // Una respuesta vacia DE VERDAD trae su finish_reason: el motor cerro el
+            // turno en regla y simplemente no dijo nada, y eso si merece un reintento
+            // porque la conexion estaba bien.
+            if (!llegoElFinal) {
                 watcher.stop();
                 // Lo que llego se guarda, pero MARCADO. Sin la marca, en el turno
                 // siguiente el modelo lee su propia frase a medias como algo que decidio
@@ -738,11 +751,20 @@ export class AgentLoop {
                         content: `${content}\n\n[Aqui se corto: la conexion con el motor se cerro a mitad de la respuesta.]`,
                     });
                 }
+                // Se dice HASTA DONDE llego, y no por cortesia: es el unico dato que
+                // distingue un corte antes de empezar de uno a mitad de frase, y en un
+                // pegado del usuario es lo unico con lo que se puede diagnosticar.
                 // Las llamadas a herramienta de un stream cortado NO se ejecutan: sus
                 // argumentos estan tan a medias como el texto.
-                const aviso = "La respuesta se corto a mitad: la conexion con el motor se cerro sin avisar. " +
-                    "Lo que llego se queda arriba. No lo reintento solo porque cada intento ocupa uno de " +
-                    "los cuatro huecos de tu licencia durante varios minutos; vuelve a pedirmelo y sigo.";
+                const hastaDonde = content.trim()
+                    ? "Lo que llego se queda arriba."
+                    : reasoning.trim()
+                        ? "Se corto antes de escribir nada: solo llego el razonamiento."
+                        : "Se corto antes de que llegara nada.";
+                const aviso = "La respuesta se corto: la conexion con el motor se cerro sin decir por que (no llego " +
+                    `ni el motivo de fin ni el recuento del gasto). ${hastaDonde} ` +
+                    "No lo reintento solo porque cada intento ocupa uno de los cuatro huecos de tu licencia " +
+                    "durante varios minutos; vuelve a pedirmelo y sigo.";
                 salida.linea(chalk.yellow(`\n  ⚠ ${aviso}\n`));
                 return parada("error-motor", aviso);
             }
@@ -845,10 +867,14 @@ export class AgentLoop {
                     for (const { tc, args } of autorizadas) {
                         renderToolStart(tc.function.name, getToolSummary(tc.function.name, args));
                     }
-                    const settled = await Promise.all(autorizadas.map(async ({ tc, args, pos }) => {
+                    // Un solo spinner para el lote entero: uno por herramienta se pisarian
+                    // entre ellos y el pie parpadearia tantas veces como llamadas haya.
+                    const settled = await conSpinner(autorizadas.length === 1
+                        ? formatToolName(autorizadas[0].tc.function.name)
+                        : `${autorizadas.length} herramientas a la vez`, () => Promise.all(autorizadas.map(async ({ tc, args, pos }) => {
                         const r = await executeToolCall(tc.function.name, args, this.currentCwd, this.apiKey, this.currentEspectro.underlyingModel);
                         return { tc, args, pos, result: r.result };
-                    }));
+                    })));
                     for (const { tc, args, pos, result } of settled) {
                         renderToolSuccess(tc.function.name, result);
                         const aviso = await notificarPostHerramienta(tc.function.name, args, result, this.currentCwd);
@@ -969,7 +995,10 @@ export class AgentLoop {
                     }
                     const summary = getToolSummary(fnName, fnArgs);
                     renderToolStart(fnName, summary);
-                    const { result, diffText, newCwd } = await executeToolCall(fnName, fnArgs, this.currentCwd, this.apiKey, this.currentEspectro.underlyingModel);
+                    // El pie se queda puesto mientras dure la herramienta. Un run_command
+                    // de veinte segundos dejaba la pantalla muda: ni cronometro, ni forma
+                    // de saber que seguia vivo, ni donde escribir para encolar algo.
+                    const { result, diffText, newCwd } = await conSpinner(formatToolName(fnName), () => executeToolCall(fnName, fnArgs, this.currentCwd, this.apiKey, this.currentEspectro.underlyingModel));
                     if (newCwd) {
                         this.currentCwd = newCwd;
                     }
@@ -1027,6 +1056,12 @@ export class AgentLoop {
             // codigo no distingue "el modelo termino" de "no vino nada". Sin
             // herramientas y sin texto, el bucle daba el turno por hecho, imprimia el
             // pie y volvia al prompt.
+            //
+            // Aqui solo se llega con la marca de final puesta: un stream cortado sale
+            // mucho antes, por su propia rama. Asi que esto es lo que parece -el motor
+            // cerro el turno en regla y no dijo nada- y no un corte disfrazado. Esa
+            // separacion es la que hace que reintentar aqui sea razonable: la conexion
+            // estaba bien, y por eso el reintento no es tirar un hueco a la basura.
             if (!content.trim()) {
                 respuestasVacias++;
                 // Se reintenta UNA vez, no mas, y aqui la moderacion importa: cada
@@ -1034,13 +1069,14 @@ export class AgentLoop {
                 // cuatro. Insistir con un motor que no contesta es la forma mas rapida
                 // de quedarse sin ninguno.
                 if (respuestasVacias > MAX_RESPUESTAS_VACIAS) {
-                    const aviso = `El motor devolvio ${respuestasVacias} respuestas vacias seguidas. ` +
-                        "No es tu conexion ni tu orden: no esta llegando nada del modelo. " +
-                        "Espera un momento y reintenta, o /clear si venias de una conversacion larga.";
+                    const aviso = `El motor cerro el turno en regla ${respuestasVacias} veces seguidas sin una sola ` +
+                        "palabra. No es un corte de conexion -eso se avisa aparte y con otras palabras-: la " +
+                        "peticion llego y volvio entera, solo que vacia. Espera un momento y reintenta, o " +
+                        "/clear si venias de una conversacion larga.";
                     salida.linea(chalk.yellow(`\n  ⚠ ${aviso}\n`));
                     return parada("error-motor", aviso);
                 }
-                salida.linea(chalk.gray("\n  ⚠ El motor no devolvio nada. Reintentando una vez…\n"));
+                salida.linea(chalk.gray("\n  ⚠ El motor cerro el turno sin decir nada. Reintentando una vez…\n"));
                 this.messages.push({
                     role: "user",
                     content: "Tu respuesta anterior llego vacia: ni texto ni llamadas a herramienta. " +

package/dist/config/quota.d.ts

@@ -50,6 +50,17 @@ export interface QuotaStatus {
     config: QuotaConfig;
 }
 export declare function checkQuota(ahora?: number): QuotaStatus;
+/**
+ * Cuando la ventana corta se vacia DEL TODO, si no se gasta nada mas.
+ *
+ * `seLiberaEn` dice cuando caduca el gasto mas viejo, que es lo que hace falta
+ * para saber cuando se puede volver a trabajar tras un corte. Para ensenar el
+ * consumo es otra pregunta: cuando vuelve a cero. Y como la ventana es
+ * deslizante, eso es cuando caduca el gasto mas RECIENTE.
+ *
+ * `null` si no hay nada dentro de la ventana: no hay nada que renovar.
+ */
+export declare function ventanaVaciaEn(ahora?: number): Date | null;
 /** Cuanto falta para la hora indicada, en lenguaje llano. */
 export declare function faltaPara(fecha: Date, ahora?: number): string;
 /** Mensaje completo para cuando se agota la cuota. */

package/dist/config/quota.js

@@ -148,6 +148,24 @@ export function checkQuota(ahora = Date.now()) {
     }
     return { allowed: true, spentWindowUsd, spentWeekUsd, config };
 }
+/**
+ * Cuando la ventana corta se vacia DEL TODO, si no se gasta nada mas.
+ *
+ * `seLiberaEn` dice cuando caduca el gasto mas viejo, que es lo que hace falta
+ * para saber cuando se puede volver a trabajar tras un corte. Para ensenar el
+ * consumo es otra pregunta: cuando vuelve a cero. Y como la ventana es
+ * deslizante, eso es cuando caduca el gasto mas RECIENTE.
+ *
+ * `null` si no hay nada dentro de la ventana: no hay nada que renovar.
+ */
+export function ventanaVaciaEn(ahora = Date.now()) {
+    const ventanaMs = getQuotaConfig().windowHours * 60 * 60 * 1000;
+    const dentro = load().filter((e) => e.t >= ahora - ventanaMs);
+    if (dentro.length === 0)
+        return null;
+    const masReciente = dentro.reduce((max, e) => (e.t > max ? e.t : max), dentro[0].t);
+    return new Date(masReciente + ventanaMs);
+}
 /** Cuanto falta para la hora indicada, en lenguaje llano. */
 export function faltaPara(fecha, ahora = Date.now()) {
     const ms = fecha.getTime() - ahora;

package/dist/index.js

@@ -5,13 +5,16 @@ import { fileURLToPath } from "node:url";
 import chalk from "chalk";
 import { ensureApiKey } from "./config/env.js";
 import { ensureLicense, licenseStatus, deactivate, getStoredLicense } from "./config/license.js";
-import { isManagedMode } from "./config/quota.js";
+import { isManagedMode, checkQuota, ventanaVaciaEn } from "./config/quota.js";
+import { construirInformeDeUso } from "./ui/informeDeUso.js";
 import { getEngineBaseUrl, DEFAULT_ESPECTRO, ESPECTRO_MODELS, RULES_FILE_NAME } from "./config/constants.js";
 import { getProjectContext } from "./agent/context.js";
 import { buildSystemPrompt } from "./prompts/systemPrompt.js";
 import { AgentLoop } from "./agent/loop.js";
 import { codigoDeSalida, EXIT_OK, EXIT_FALLO, EXIT_USO, EXIT_LICENCIA } from "./agent/result.js";
 import { showBanner, animateStartupBanner, showHelp, showEffortMenu } from "./ui/banner.js";
+import { fijarMotor } from "./ui/motorActual.js";
+import { elegirDeLista } from "./ui/selector.js";
 import { askInteractivePrompt, SLASH_COMMANDS } from "./ui/prompt.js";
 import { changeDir } from "./tools/changeDir.js";
 import { gitDiff, gitCommit } from "./tools/gitTools.js";
@@ -184,8 +187,8 @@ async function main() {
     // errores raros dentro de una dependencia. Ver config/nodeVersion.ts.
     const nodeViejo = comprobarNode();
     if (nodeViejo) {
-        console.error(chalk.red(`
-${nodeViejo}
+        console.error(chalk.red(`
+${nodeViejo}
 `));
         process.exit(EXIT_USO);
     }
@@ -232,6 +235,9 @@ ${nodeViejo}
     const sessionManager = new SessionManager();
     const sessionId = `session_${Date.now()}`;
     let currentModel = DEFAULT_ESPECTRO;
+    // La barra de estado lo lee de aqui. Fijarlo al arrancar y no solo al
+    // cambiarlo: si no, hasta el primer /effort la barra no dice nada.
+    fijarMotor(currentModel.name);
     let isPlanMode = false;
     let systemPrompt = buildSystemPrompt(context, currentModel, skillManager, memoryManager, isPlanMode);
     const agent = new AgentLoop(apiKey, getEngineBaseUrl(), currentModel, systemPrompt);
@@ -399,15 +405,15 @@ ${nodeViejo}
                 .filter((m) => m.role === "user" || m.role === "assistant")
                 .map((m) => `### 👤 ${m.role === "user" ? "Usuario" : "Chocolatito"}\n\n${typeof m.content === "string" ? m.content : JSON.stringify(m.content, null, 2)}\n`)
                 .join("\n---\n\n");
-            const mdContent = `# 🦊 Bitácora de Sesión — Chocolatito Code
-**Fecha:** ${new Date().toLocaleString()}  
-**Directorio:** \`${agent.currentCwd}\`  
-**Motor:** ${currentModel.name}  
-**Inversión Total:** ${agent.tracker.calculateCost(undefined, undefined, undefined, currentModel.underlyingModel).formattedCost}  
-
----
-
-${sessionData}
+            const mdContent = `# 🦊 Bitácora de Sesión — Chocolatito Code
+**Fecha:** ${new Date().toLocaleString()}  
+**Directorio:** \`${agent.currentCwd}\`  
+**Motor:** ${currentModel.name}  
+**Inversión Total:** ${agent.tracker.calculateCost(undefined, undefined, undefined, currentModel.underlyingModel).formattedCost}  
+
+---
+
+${sessionData}
 `;
             fs.writeFileSync(exportPath, mdContent, "utf-8");
             console.log(chalk.green(`\n✔ Bitácora exportada exitosamente en: ${chalk.bold.white(exportPath)}\n`));
@@ -428,6 +434,7 @@ ${sessionData}
                 const restauracion = prepararRestauracion(loaded, { cwd: agent.currentCwd, modelId: currentModel.id });
                 agent.currentCwd = restauracion.cwd;
                 currentModel = ESPECTRO_MODELS[restauracion.modelId] || currentModel;
+                fijarMotor(currentModel.name);
                 const refreshedContext = await getProjectContext(agent.currentCwd);
                 systemPrompt = buildSystemPrompt(refreshedContext, currentModel, skillManager, memoryManager, isPlanMode);
                 agent.messages = [{ role: "system", content: systemPrompt }, ...restauracion.conversacion];
@@ -500,12 +507,12 @@ ${sessionData}
             }
             console.log(chalk.bold.hex("#A855F7")("\n🎯 INICIANDO MODO META AUTÓNOMA (GOAL MODE):"));
             console.log(chalk.gray(`  Objetivo: "${goalText}"\n`));
-            const autonomousPrompt = `[MODO META AUTÓNOMA ACTIVADO]
-Tu objetivo principal es: "${goalText}"
-Directivas de ejecución:
-1. Formula un plan de ejecución mental paso a paso.
-2. Ejecuta cada paso utilizando las herramientas correspondientes (creación, edición, ejecución, verificación).
-3. Si algo falla o hay errores, autocorregir inmediatamente y volver a probar.
+            const autonomousPrompt = `[MODO META AUTÓNOMA ACTIVADO]
+Tu objetivo principal es: "${goalText}"
+Directivas de ejecución:
+1. Formula un plan de ejecución mental paso a paso.
+2. Ejecuta cada paso utilizando las herramientas correspondientes (creación, edición, ejecución, verificación).
+3. Si algo falla o hay errores, autocorregir inmediatamente y volver a probar.
 4. No te detengas hasta verificar que el objetivo esté 100% completado con éxito.`;
             renderUserPrompt(`/goal ${goalText}`);
             await agent.runTask(autonomousPrompt);
@@ -559,32 +566,63 @@ Directivas de ejecución:
             }
             continue;
         }
-        if (trimmed === "/cost") {
-            const { formattedCost, inputCost, outputCost } = agent.tracker.calculateCost(undefined, undefined, undefined, currentModel.underlyingModel);
-            console.log(chalk.bold.hex("#A855F7")("\n📊 REPORTE DE CONSUMO DE SESIÓN:") +
-                `\n  ${chalk.gray("• Motor activo:")}    ${chalk.bold.white(currentModel.name)}` +
-                `\n  ${chalk.gray("• Tokens entrada:")}  ${agent.tracker.totalPromptTokens.toLocaleString()} ($${inputCost.toFixed(5)} USD)` +
-                `\n  ${chalk.gray("• Tokens memoria:")}  ${agent.tracker.cachedPromptTokens.toLocaleString()} (90% de ahorro en caché)` +
-                `\n  ${chalk.gray("• Tokens salida:")}   ${agent.tracker.totalCompletionTokens.toLocaleString()} ($${outputCost.toFixed(5)} USD)` +
-                `\n  ${chalk.gray("• Inversión total:")} ${chalk.bold.green(formattedCost)}\n`);
+        // "/cost" sigue funcionando sin anunciarse: el nombre viejo esta en la
+        // memoria de los dedos de quien ya lo usaba, y quitarlo de golpe solo
+        // ensena un "comando desconocido" a quien no ha hecho nada mal.
+        if (trimmed === "/uso" || trimmed === "/cost") {
+            // Lo que se ensena es la CUENTA, no la tarifa: quien paga una suscripcion
+            // plana no puede hacer nada con "$0.00508", y lo unico que necesita saber
+            // es cuanto le queda antes de que esto le pare. Con clave propia es al
+            // reves -el dinero es suyo- y el informe lo tiene en cuenta.
+            const { formattedCost } = agent.tracker.calculateCost(undefined, undefined, undefined, currentModel.underlyingModel);
+            console.log(construirInformeDeUso(checkQuota(), {
+                motor: currentModel.name,
+                tokensEntrada: agent.tracker.totalPromptTokens,
+                tokensSalida: agent.tracker.totalCompletionTokens,
+                tokensEnCache: agent.tracker.cachedPromptTokens,
+                costeFormateado: formattedCost,
+            }, ventanaVaciaEn()));
             continue;
         }
         if (trimmed.startsWith("/effort") || trimmed.startsWith("/espectro") || trimmed === "/model") {
             const parts = trimmed.split(/\s+/);
-            const targetId = parts[1]?.trim();
+            let targetId = parts[1]?.trim();
+            // Sin argumento se ABRE UN MENU, no se imprime una lista.
+            //
+            // Antes se volcaban las cuatro opciones con console.log y una frase al
+            // final que decia "selecciona con /effort 2.0". En pantalla se veia una
+            // lista, la gente pulsaba las flechas -que es lo unico razonable- y no
+            // pasaba nada.
             if (!targetId || !ESPECTRO_MODELS[targetId]) {
-                showEffortMenu(currentModel.id);
-            }
-            else {
-                currentModel = ESPECTRO_MODELS[targetId];
-                const refreshedContext = await getProjectContext(agent.currentCwd);
-                const updatedPrompt = buildSystemPrompt(refreshedContext, currentModel, skillManager, memoryManager, isPlanMode);
-                agent.setEspectroModel(currentModel, updatedPrompt);
-                console.log(chalk.green(`\n✔ Nivel actualizado a `) +
-                    chalk.bold.hex("#A855F7")(currentModel.name) +
-                    chalk.gray(` (${currentModel.effortLevel})`) +
-                    `\n  ${chalk.italic.gray(currentModel.description)}\n`);
+                const opciones = Object.values(ESPECTRO_MODELS).map((m) => ({
+                    id: m.id,
+                    titulo: `${m.name}  ${m.id === currentModel.id ? "· activo" : ""}`.trimEnd(),
+                    detalle: `Esfuerzo ${m.effortLevel} — ${m.description}`,
+                }));
+                const indiceActual = Object.values(ESPECTRO_MODELS).findIndex((m) => m.id === currentModel.id);
+                const elegido = await elegirDeLista("POTENCIA DEL MOTOR — CHOCOLATITO CODE", opciones, Math.max(0, indiceActual));
+                // Sin terminal el menu no puede abrirse: ahi se cae a la lista de
+                // siempre, que al menos dice como elegir escribiendolo.
+                if (elegido === null) {
+                    if (!process.stdin.isTTY)
+                        showEffortMenu(currentModel.id);
+                    continue;
+                }
+                targetId = elegido;
             }
+            currentModel = ESPECTRO_MODELS[targetId];
+            // Sin esto la barra de abajo sigue anunciando el motor anterior.
+            fijarMotor(currentModel.name);
+            const refreshedContext = await getProjectContext(agent.currentCwd);
+            const updatedPrompt = buildSystemPrompt(refreshedContext, currentModel, skillManager, memoryManager, isPlanMode);
+            agent.setEspectroModel(currentModel, updatedPrompt);
+            console.log(chalk.green(`
+✔ Nivel actualizado a `) +
+                chalk.bold.hex("#A855F7")(currentModel.name) +
+                chalk.gray(` (${currentModel.effortLevel})`) +
+                `
+  ${chalk.italic.gray(currentModel.description)}
+`);
             continue;
         }
         if (trimmed === "/clear") {