chocolatito-code 1.1.0 → 1.3.0

package/README.md

@@ -85,6 +85,55 @@ Si repite tres veces la misma llamada con el mismo resultado, se para y pregunta
 seguir, o le dices que cambie de enfoque. Sin terminal (CI, `chocolatito "haz X"`) se corta
 solo, para que un bucle que nadie está mirando no se coma la cuota.
 
+## 🧩 VSCode
+
+Si tienes la extensión instalada y abres `chocolatito` en la terminal integrada, **se conecta
+solo**. No hay nada que configurar.
+
+El truco está al revés de lo que parece: la extensión es un **servidor MCP** y el agente es el
+cliente. Cada ventana de VSCode levanta un servidor en `127.0.0.1` y deja una ficha en
+`~/.chocolatito/ide/` con su puerto, su token y la carpeta que tiene abierta. El agente busca la
+ficha cuya carpeta contiene su directorio de trabajo.
+
+Lo que gana el agente (lo único que no puede tener por su cuenta):
+
+| Herramienta | Para qué |
+| --- | --- |
+| `diagnosticos` | Los errores del servidor de lenguaje. Los subrayados rojos, sin esperar a compilar. |
+| `seleccion_actual` | Qué archivo tienes abierto y qué has seleccionado. Hace que «arregla esto» signifique algo. |
+| `archivos_abiertos` | Las pestañas abiertas, en orden. |
+| `mostrar_diff` | Abre el visor de diferencias nativo. No escribe nada: es para que lo veas antes. |
+
+**Con varias ventanas abiertas se elige la correcta**, no la primera: gana la carpeta más
+específica que contenga el directorio de trabajo, y si ninguna lo contiene **no se conecta a
+nada**. Conectarse a la ventana de otro proyecto sería peor que no conectarse: los diffs saldrían
+en el sitio equivocado.
+
+El servidor escucha solo en `127.0.0.1` y exige un token de 32 bytes que va en la ficha, dentro de
+tu carpeta personal. Sin eso, cualquier programa de la máquina podría manejar tu editor.
+
+Para apagarlo: `CHOCOLATITO_SIN_EDITOR=1`, o la opción `chocolatito.puente` en VSCode.
+
+### Instalarla
+
+Mientras no esté en el marketplace, se instala desde el paquete:
+
+```bash
+cd extension-vscode
+npx @vscode/vsce package --allow-missing-repository --skip-license
+code --install-extension chocolatito-code-vscode-0.1.1.vsix
+```
+
+**Con VSCode cerrado**, y reiniciándolo después. Copiar la carpeta a mano a `~/.vscode/extensions`
+**no funciona**: falta el `.vsixmanifest` y VSCode la lista pero no la carga nunca, sin dar ningún
+error. Para desarrollar, `F5` sobre la carpeta abre una ventana con la extensión cargada al vuelo.
+
+En la barra de estado, abajo a la derecha, pone **Chocolatito** con el estado del puente. Si algo
+falla —sin carpeta abierta, puente apagado, puerto ocupado— lo dice ahí, y al pulsarlo se abre el
+detalle.
+
+---
+
 ## 🔌 MCP (Model Context Protocol)
 
 Conecta cualquier servidor MCP y sus herramientas quedan disponibles para el agente.
@@ -141,6 +190,23 @@ solo lectura de verdad: ni comandos, ni clics, ni escrituras.
 
 `--yes` aprueba todo sin preguntar: es para CI, no para el día a día.
 
+## 📋 Pegar texto largo
+
+Pegar un log de 300 líneas ya no mete 300 líneas en el recuadro. Se guarda aparte y en el prompt
+queda una marca corta:
+
+```
+❯ arregla esto [pegado #1 · 347 lineas]
+```
+
+**El modelo recibe el texto entero**, no la marca: al enviar se sustituye por lo que pegaste. Y un
+solo `backspace` con el cursor detrás de la marca se la lleva completa — lo que ocupa una línea se
+borra como una línea.
+
+Por debajo de 5 líneas o 400 caracteres se pega normal, entero y a la vista.
+
+---
+
 ## ⌨️ Escribir mientras trabaja
 
 No hace falta esperar a que termine. Lo que escribas durante una generación aparece bajo

package/dist/agent/huecos.d.ts

@@ -0,0 +1,58 @@
+/**
+ * NO GASTAR UN HUECO DE PETICION QUE YA SABEMOS QUE NO HAY
+ *
+ * DE DONDE SALE
+ *
+ * Sesion real. Una respuesta se corto a mitad, el bucle reintento, y en cuatro
+ * mensajes el usuario se quedo sin servicio:
+ *
+ *     ⏸  Tienes 4 peticiones en curso. Reintenta en 197s.
+ *     ❯ q paso?
+ *     ⏸  Tienes 4 peticiones en curso. Reintenta en 189s.
+ *
+ * Fijate en la segunda. El agente ya SABIA que no habia huecos y que faltaban
+ * 197 segundos; ocho segundos despues volvio a llamar al motor para que se lo
+ * repitiera. Esa llamada no podia salir bien por definicion, y ademas es la
+ * clase de peticion que puede refrescar la reserva del proxy y alargar la
+ * espera. El usuario tecleaba, esperaba, y se llevaba la misma pared.
+ *
+ * LO QUE HACE
+ *
+ * Se apunta hasta cuando no hay huecos y se responde desde aqui, sin red. Deja
+ * de gastarse una peticion por cada intento y el usuario ve la cuenta atras
+ * bajar de verdad en lugar de quedarse clavada.
+ *
+ * POR QUE NO SE FIA DEL RELOJ A CIEGAS
+ *
+ * Un reloj que se adelanta desbloquea antes de tiempo -inofensivo, la siguiente
+ * peticion dira la verdad-. Pero uno que se atrasa dejaria `ocupadoHasta` en un
+ * futuro lejano y el agente se negaria a llamar al motor durante horas sin que
+ * nada lo despierte. Por eso la espera nunca puede pasar de la ventana que se
+ * anoto: en el peor caso se espera de mas una vez, no para siempre.
+ */
+/** Cuando el proxy no dice cuanto falta. Un minuto es su reserva mas corta. */
+export declare const SEGUNDOS_POR_DEFECTO = 60;
+/** Techo de la espera. Ninguna reserva del proxy dura mas de unos minutos. */
+export declare const SEGUNDOS_MAXIMOS = 300;
+/**
+ * Apunta que los huecos estan llenos.
+ *
+ * `retryAfterS` es lo que dice el proxy en `error.retry_after_s`. Si no viene,
+ * o viene con un valor absurdo, se usa un minuto: adivinar de mas encierra al
+ * usuario y adivinar de menos le devuelve a la misma pared.
+ */
+export declare function anotarHuecosOcupados(retryAfterS?: unknown): void;
+/** Segundos que faltan para volver a tener hueco. 0 si ya lo hay. */
+export declare function segundosDeEspera(): number;
+/**
+ * Olvida la espera. Se llama en cuanto el motor concede una peticion: si
+ * contesta, es que habia hueco, y seguir bloqueando seria mentir.
+ */
+export declare function liberarHuecos(): void;
+/**
+ * Lo que se le dice al usuario en vez de llamar al motor.
+ *
+ * Dice de donde sale la cuenta -no es una invencion del cliente- y que no tiene
+ * que hacer nada: es lo unico que se arregla solo con esperar.
+ */
+export declare function mensajeDeEspera(segundos: number): string;

package/dist/agent/huecos.js

@@ -0,0 +1,81 @@
+/**
+ * NO GASTAR UN HUECO DE PETICION QUE YA SABEMOS QUE NO HAY
+ *
+ * DE DONDE SALE
+ *
+ * Sesion real. Una respuesta se corto a mitad, el bucle reintento, y en cuatro
+ * mensajes el usuario se quedo sin servicio:
+ *
+ *     ⏸  Tienes 4 peticiones en curso. Reintenta en 197s.
+ *     ❯ q paso?
+ *     ⏸  Tienes 4 peticiones en curso. Reintenta en 189s.
+ *
+ * Fijate en la segunda. El agente ya SABIA que no habia huecos y que faltaban
+ * 197 segundos; ocho segundos despues volvio a llamar al motor para que se lo
+ * repitiera. Esa llamada no podia salir bien por definicion, y ademas es la
+ * clase de peticion que puede refrescar la reserva del proxy y alargar la
+ * espera. El usuario tecleaba, esperaba, y se llevaba la misma pared.
+ *
+ * LO QUE HACE
+ *
+ * Se apunta hasta cuando no hay huecos y se responde desde aqui, sin red. Deja
+ * de gastarse una peticion por cada intento y el usuario ve la cuenta atras
+ * bajar de verdad en lugar de quedarse clavada.
+ *
+ * POR QUE NO SE FIA DEL RELOJ A CIEGAS
+ *
+ * Un reloj que se adelanta desbloquea antes de tiempo -inofensivo, la siguiente
+ * peticion dira la verdad-. Pero uno que se atrasa dejaria `ocupadoHasta` en un
+ * futuro lejano y el agente se negaria a llamar al motor durante horas sin que
+ * nada lo despierte. Por eso la espera nunca puede pasar de la ventana que se
+ * anoto: en el peor caso se espera de mas una vez, no para siempre.
+ */
+/** Cuando el proxy no dice cuanto falta. Un minuto es su reserva mas corta. */
+export const SEGUNDOS_POR_DEFECTO = 60;
+/** Techo de la espera. Ninguna reserva del proxy dura mas de unos minutos. */
+export const SEGUNDOS_MAXIMOS = 300;
+let ocupadoHasta = 0;
+let ventanaMs = 0;
+/**
+ * Apunta que los huecos estan llenos.
+ *
+ * `retryAfterS` es lo que dice el proxy en `error.retry_after_s`. Si no viene,
+ * o viene con un valor absurdo, se usa un minuto: adivinar de mas encierra al
+ * usuario y adivinar de menos le devuelve a la misma pared.
+ */
+export function anotarHuecosOcupados(retryAfterS) {
+    const dicho = Number(retryAfterS);
+    const segundos = Number.isFinite(dicho) && dicho > 0 ? Math.min(dicho, SEGUNDOS_MAXIMOS) : SEGUNDOS_POR_DEFECTO;
+    ventanaMs = segundos * 1000;
+    ocupadoHasta = Date.now() + ventanaMs;
+}
+/** Segundos que faltan para volver a tener hueco. 0 si ya lo hay. */
+export function segundosDeEspera() {
+    if (ocupadoHasta === 0)
+        return 0;
+    const faltan = Math.min(ocupadoHasta - Date.now(), ventanaMs);
+    if (faltan <= 0) {
+        liberarHuecos();
+        return 0;
+    }
+    return Math.ceil(faltan / 1000);
+}
+/**
+ * Olvida la espera. Se llama en cuanto el motor concede una peticion: si
+ * contesta, es que habia hueco, y seguir bloqueando seria mentir.
+ */
+export function liberarHuecos() {
+    ocupadoHasta = 0;
+    ventanaMs = 0;
+}
+/**
+ * Lo que se le dice al usuario en vez de llamar al motor.
+ *
+ * Dice de donde sale la cuenta -no es una invencion del cliente- y que no tiene
+ * que hacer nada: es lo unico que se arregla solo con esperar.
+ */
+export function mensajeDeEspera(segundos) {
+    return (`Los huecos de peticion de tu licencia siguen ocupados. Faltan ${segundos}s. ` +
+        "No llamo al motor porque la respuesta seria la misma y cada intento puede alargar la espera. " +
+        "No hace falta que hagas nada: el hueco se libera solo.");
+}