chocolatito-code 1.6.7 → 1.6.8

package/dist/index.js

@@ -16,6 +16,9 @@ import { showBanner, animateStartupBanner, showHelp, showEffortMenu } from "./ui
 import { fijarMotor } from "./ui/motorActual.js";
 import { elegirDeLista } from "./ui/selector.js";
 import { entrarEnPantallaFija, pantallaFijaPedida, salirDePantallaFija } from "./ui/pantalla.js";
+import { iniciarServidorWeb } from "./servidor/servidor.js";
+import { iniciarCaptura } from "./servidor/captura.js";
+import { entregarEntrada, esperarEntradaWeb, marcarServirActivo } from "./servidor/puente.js";
 import { montarArbol, desmontarArbol } from "./ui/ink/montarApp.js";
 import { reafirmarModoCrudo } from "./ui/keyboardGuard.js";
 import { askInteractivePrompt, SLASH_COMMANDS } from "./ui/prompt.js";
@@ -27,7 +30,8 @@ import { SkillManager } from "./skills/manager.js";
 import { MemoryManager } from "./memory/manager.js";
 import { HookManager } from "./hooks/manager.js";
 import { SessionManager } from "./sessions/manager.js";
-import { prepararRestauracion } from "./sessions/resume.js";
+import { prepararRestauracion, formatearOpcionesDeSesion } from "./sessions/resume.js";
+import { auditGitDiff, formatAuditReport } from "./tools/gitAudit.js";
 import { globalUndoManager } from "./agent/undoManager.js";
 import { setAutoApprove } from "./ui/permissionPrompt.js";
 import { onModeChange, getMode, modeAnnouncement } from "./ui/modes.js";
@@ -76,6 +80,9 @@ function handleFlags(argv) {
             "",
             "OPCIONES",
             "  -y, --yes         Aprueba las acciones sin preguntar (util en CI).",
+            "  --servir          Abre la sesion en el navegador (solo esta maquina).",
+            "  --servir-red      Igual, pero accesible desde tu red local (movil, tablet).",
+            "  --puerto N        Puerto para --servir (por defecto 4700).",
             "  -v, --version     Muestra la version instalada.",
             "  -h, --help        Muestra esta ayuda.",
             "",
@@ -222,7 +229,16 @@ ${nodeViejo}
     instalarRedDeSeguridad();
     // --yes / -y aprueba las acciones sin preguntar. Util en modo comando unico y CI.
     const autoYes = rawArgs.includes("--yes") || rawArgs.includes("-y");
-    const args = rawArgs.filter((a) => a !== "--yes" && a !== "-y");
+    // --servir abre la sesion en el navegador; --servir-red ademas la saca a la
+    // red local, que es lo que hace falta para entrar desde el movil.
+    const enRed = rawArgs.includes("--servir-red");
+    const quiereServir = enRed || rawArgs.includes("--servir");
+    const posPuerto = rawArgs.indexOf("--puerto");
+    const puertoWeb = posPuerto >= 0 ? Number(rawArgs[posPuerto + 1]) || 0 : 0;
+    // Ojo: lo que sobra de argv se convierte en la orden a ejecutar. Una bandera
+    // que no se filtre aqui no es una bandera ignorada, es una orden al modelo.
+    const banderas = new Set(["--yes", "-y", "--servir", "--servir-red", "--puerto"]);
+    const args = rawArgs.filter((a, i) => !banderas.has(a) && !(posPuerto >= 0 && i === posPuerto + 1 && puertoWeb > 0));
     const singlePrompt = args.join(" ").trim();
     // Los errores de uso se resuelven ANTES de la licencia y de la API key: no
     // dependen de estar suscrito, y en CI hay que poder distinguir "lo has
@@ -234,7 +250,7 @@ ${nodeViejo}
     }
     // Sin orden y sin terminal no hay a quien preguntar: el REPL moria en el
     // primer prompt y salia con 0, que en CI se lee como "todo bien".
-    if (!singlePrompt && !process.stdin.isTTY) {
+    if (!singlePrompt && !process.stdin.isTTY && !quiereServir) {
         console.error(chalk.red("\n✖ La entrada no es una terminal y no se dio ninguna orden.") +
             chalk.gray('\n  En scripts y CI usa: chocolatito --yes "haz X".\n'));
         process.exit(EXIT_USO);
@@ -254,7 +270,7 @@ ${nodeViejo}
         : await ensureApiKey();
     const context = await getProjectContext(process.cwd());
     const skillManager = new SkillManager(context.cwd);
-    const memoryManager = new MemoryManager();
+    const memoryManager = new MemoryManager(context.cwd);
     const hookManager = new HookManager(context.cwd);
     const sessionManager = new SessionManager();
     const sessionId = `session_${Date.now()}`;
@@ -320,7 +336,9 @@ ${nodeViejo}
         SLASH_COMMANDS.splice(1, 0, { name: "/resume", description: "Reanudar una sesión anterior guardada", args: "[id]" });
     }
     // Single-command mode: chocolatito "crea index.html"
-    if (singlePrompt) {
+    // Con --servir no: ahi la orden es solo la PRIMERA de una sesion que sigue
+    // viva esperando al navegador, no una tarea suelta que termina y cierra.
+    if (singlePrompt && !quiereServir) {
         showBanner(context.cwd, currentModel, "idle");
         renderUserPrompt(singlePrompt);
         // El modo no interactivo pasa por los mismos hooks que el REPL: un veto que
@@ -382,6 +400,46 @@ ${nodeViejo}
         // que haya nadie pintandolo deja la consola muda.
         montarArbol();
     }
+    // EL SERVIDOR WEB, SI SE PIDIO
+    //
+    // Va DESPUES de montar el arbol, y el orden no es casual: ui/pantalla.ts ya
+    // reemplazo los cuatro canales de console para mandarlos a la transcripcion, y
+    // la captura tiene que envolver ESA version. Al reves, pantalla envolveria a la
+    // captura y al navegador no llegaria nada. Ver servidor/captura.ts.
+    if (quiereServir) {
+        try {
+            iniciarCaptura();
+            const web = await iniciarServidorWeb({ puerto: puertoWeb || undefined, enRed });
+            marcarServirActivo(true);
+            console.log(chalk.hex("#e8833a")("\n  🦊 Sesión abierta en el navegador\n"));
+            console.log(`  ${chalk.bold("Aquí:")}     ${chalk.cyan(web.url)}`);
+            for (const dir of web.urlsDeRed) {
+                console.log(`  ${chalk.bold("Del móvil:")} ${chalk.cyan(dir)}`);
+            }
+            if (!enRed) {
+                console.log(chalk.gray("\n  Solo desde esta máquina. Para entrar desde el móvil: --servir-red"));
+            }
+            else {
+                console.log(chalk.yellow("\n  ⚠ Abierto a tu red local.") +
+                    chalk.gray(" Cualquiera que tenga el enlace COMPLETO (con el token)" +
+                        "\n    puede usar esta sesión. No lo pegues en ningún sitio compartido."));
+            }
+            console.log(chalk.gray("\n  Lo que escribas aquí ya no se lee: manda el navegador y este terminal es el monitor.\n"));
+            // Una orden en la linea de comandos con --servir es la PRIMERA del turno,
+            // no una tarea suelta: entra por la misma puerta que lo que llegue del movil.
+            if (singlePrompt)
+                entregarEntrada(singlePrompt);
+        }
+        catch (err) {
+            const ocupado = err?.code === "EADDRINUSE";
+            const motivo = ocupado ? "el puerto ya está ocupado" : err?.message || String(err);
+            console.error(chalk.red("\n✖ No se pudo abrir la sesión web: " + motivo));
+            if (ocupado)
+                console.error(chalk.gray("  Prueba con otro: chocolatito --servir --puerto 4701"));
+            console.error("");
+            process.exit(EXIT_USO);
+        }
+    }
     // Lo que el usuario escribio mientras el agente trabajaba entra como siguiente
     // orden, sin tener que volver a teclearlo.
     let pendiente = null;
@@ -404,6 +462,15 @@ ${nodeViejo}
             stopYaForzado = false;
             renderUserPrompt(userInput);
         }
+        else if (quiereServir) {
+            // Manda el navegador. No se corre tambien el prompt del teclado a ver cual
+            // contesta primero: askInteractivePrompt se queda con el TTY prestado y no
+            // sabe cancelarse a medias, y dos entradas peleando por el mismo terminal
+            // es exactamente lo que dejo la pantalla en negro dos veces.
+            userInput = await esperarEntradaWeb();
+            stopYaForzado = false;
+            renderUserPrompt(userInput);
+        }
         else {
             try {
                 userInput = await askInteractivePrompt(isPlanMode ? chalk.cyan("plan ❯") : "❯", agent.currentCwd);
@@ -472,7 +539,27 @@ ${sessionData}
             continue;
         }
         if (trimmed.startsWith("/resume")) {
-            const targetId = trimmed.slice(7).trim();
+            let targetId = trimmed.slice(7).trim();
+            if (!targetId) {
+                const detailedSessions = sessionManager.listSessionsDetailed();
+                if (detailedSessions.length === 0) {
+                    console.log(chalk.yellow("\n⚠ No hay sesiones guardadas previas.\n"));
+                    continue;
+                }
+                if (process.stdin.isTTY) {
+                    const opciones = formatearOpcionesDeSesion(detailedSessions);
+                    const elegido = await elegirDeLista("REANUDAR SESIÓN — CHOCOLATITO CODE", opciones);
+                    if (elegido === null) {
+                        continue;
+                    }
+                    targetId = elegido;
+                }
+                else {
+                    const latest = sessionManager.loadLatestSession();
+                    if (latest)
+                        targetId = latest.id;
+                }
+            }
             const loaded = targetId ? sessionManager.loadSession(targetId) : sessionManager.loadLatestSession();
             if (loaded) {
                 // Se restaura la conversacion, no el entorno. El array guardado trae en
@@ -586,6 +673,11 @@ Directivas de ejecución:
             console.log(diffOut ? chalk.gray(diffOut) : chalk.green("✔ Sin cambios pendientes.") + "\n");
             continue;
         }
+        if (trimmed === "/audit" || trimmed === "/review" || trimmed.startsWith("/audit ") || trimmed.startsWith("/review ")) {
+            const report = await auditGitDiff(agent.currentCwd);
+            console.log(formatAuditReport(report));
+            continue;
+        }
         if (trimmed.startsWith("/commit")) {
             const msg = trimmed.slice(7).trim();
             if (!msg) {
@@ -602,6 +694,7 @@ Directivas de ejecución:
             const res = await changeDir(target, agent.currentCwd);
             if (res.success) {
                 agent.currentCwd = res.newCwd;
+                memoryManager.setCwd(agent.currentCwd);
                 const refreshedContext = await getProjectContext(agent.currentCwd);
                 systemPrompt = buildSystemPrompt(refreshedContext, currentModel, skillManager, memoryManager, isPlanMode);
                 agent.clearHistory(systemPrompt);

package/dist/memory/manager.d.ts

@@ -1,9 +1,19 @@
+export type MemoryScope = "project" | "global";
 export declare class MemoryManager {
-    private memoryDir;
-    private memoryIndexPath;
-    constructor();
+    private cwd;
+    constructor(cwd?: string);
+    setCwd(cwd: string): void;
+    getCwd(): string;
+    private getGlobalDir;
+    private getProjectDir;
+    private isSamePath;
+    private isProjectCwdValid;
+    private resolveScope;
+    private getDirForScope;
     private ensureDirectory;
+    private sanitizeTopic;
+    private readIndexEntries;
     getMemoryIndex(): string;
-    saveMemory(topic: string, fact: string): string;
-    readMemory(topic: string): string;
+    saveMemory(topic: string, fact: string, scope?: MemoryScope): string;
+    readMemory(topic: string, scope?: MemoryScope): string;
 }

package/dist/memory/manager.js

@@ -2,35 +2,118 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 export class MemoryManager {
-    memoryDir;
-    memoryIndexPath;
-    constructor() {
-        this.memoryDir = path.join(os.homedir(), ".chocolatito", "memory");
-        this.memoryIndexPath = path.join(this.memoryDir, "MEMORY.md");
-        this.ensureDirectory();
+    cwd;
+    constructor(cwd = process.cwd()) {
+        this.cwd = path.resolve(cwd || process.cwd());
     }
-    ensureDirectory() {
-        if (!fs.existsSync(this.memoryDir)) {
-            fs.mkdirSync(this.memoryDir, { recursive: true });
-        }
-        if (!fs.existsSync(this.memoryIndexPath)) {
-            const defaultIndex = `# 🧠 Memoria Persistente de Chocolatito Code\n\nEste archivo indexa hechos, preferencias del usuario y aprendizajes clave entre proyectos.\n\n- [Preferencias Generales](./preferences.md): Preferencias de desarrollo y estilo.\n`;
-            fs.writeFileSync(this.memoryIndexPath, defaultIndex, "utf-8");
+    setCwd(cwd) {
+        this.cwd = path.resolve(cwd || process.cwd());
+    }
+    getCwd() {
+        return this.cwd;
+    }
+    getGlobalDir() {
+        return path.join(os.homedir(), ".chocolatito", "memory");
+    }
+    getProjectDir() {
+        return path.join(this.cwd, ".chocolatito", "memory");
+    }
+    isSamePath(p1, p2) {
+        const r1 = path.resolve(p1);
+        const r2 = path.resolve(p2);
+        if (process.platform === "win32") {
+            return r1.toLowerCase() === r2.toLowerCase();
         }
+        return r1 === r2;
     }
-    getMemoryIndex() {
-        this.ensureDirectory();
+    isProjectCwdValid() {
+        if (!this.cwd || typeof this.cwd !== "string")
+            return false;
         try {
-            return fs.readFileSync(this.memoryIndexPath, "utf-8");
+            if (this.isSamePath(this.cwd, os.homedir())) {
+                return false;
+            }
+            return true;
         }
         catch {
+            return false;
+        }
+    }
+    resolveScope(scope) {
+        if (scope === "project" || scope === "global") {
+            return scope;
+        }
+        return this.isProjectCwdValid() ? "project" : "global";
+    }
+    getDirForScope(scope) {
+        return scope === "project" ? this.getProjectDir() : this.getGlobalDir();
+    }
+    ensureDirectory(scope) {
+        const dir = this.getDirForScope(scope);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        return dir;
+    }
+    sanitizeTopic(topic) {
+        return topic.toLowerCase().replace(/[^a-z0-9_-]/g, "_");
+    }
+    readIndexEntries(dir) {
+        if (!fs.existsSync(dir))
+            return null;
+        const indexPath = path.join(dir, "MEMORY.md");
+        if (fs.existsSync(indexPath)) {
+            const content = fs.readFileSync(indexPath, "utf-8").trim();
+            const lines = content
+                .split("\n")
+                .map((l) => l.trim())
+                .filter((l) => l.length > 0 && (l.startsWith("-") || l.startsWith("*")));
+            if (lines.length > 0) {
+                return lines.join("\n");
+            }
+            if (content.length > 0) {
+                return content;
+            }
+        }
+        try {
+            const files = fs
+                .readdirSync(dir)
+                .filter((f) => f.endsWith(".md") && f !== "MEMORY.md");
+            if (files.length > 0) {
+                return files
+                    .map((f) => {
+                    const topic = f.replace(/\.md$/, "");
+                    return `- [${topic}](./${f}): Registro de ${topic}.`;
+                })
+                    .join("\n");
+            }
+        }
+        catch { }
+        return null;
+    }
+    getMemoryIndex() {
+        const isProjectValid = this.isProjectCwdValid();
+        const projectEntries = isProjectValid ? this.readIndexEntries(this.getProjectDir()) : null;
+        const globalEntries = this.readIndexEntries(this.getGlobalDir());
+        const hasProject = Boolean(projectEntries);
+        const hasGlobal = Boolean(globalEntries);
+        if (!hasProject && !hasGlobal) {
             return "Sin memoria previa.";
         }
+        const projectSection = hasProject
+            ? projectEntries
+            : "Sin notas locales para este proyecto.";
+        const globalSection = hasGlobal
+            ? globalEntries
+            : "Sin preferencias globales.";
+        return `Memoria del Proyecto (.chocolatito/memory/):\n${projectSection}\n\nPreferencias Globales (~/.chocolatito/memory/):\n${globalSection}`;
     }
-    saveMemory(topic, fact) {
-        this.ensureDirectory();
-        const sanitized = topic.toLowerCase().replace(/[^a-z0-9_-]/g, "_");
-        const filePath = path.join(this.memoryDir, `${sanitized}.md`);
+    saveMemory(topic, fact, scope) {
+        const resolvedScope = this.resolveScope(scope);
+        const dir = this.ensureDirectory(resolvedScope);
+        const sanitized = this.sanitizeTopic(topic);
+        const filePath = path.join(dir, `${sanitized}.md`);
+        const indexPath = path.join(dir, "MEMORY.md");
         const timestamp = new Date().toISOString().split("T")[0];
         const entry = `\n- [${timestamp}] ${fact}`;
         if (fs.existsSync(filePath)) {
@@ -40,19 +123,53 @@ export class MemoryManager {
             fs.writeFileSync(filePath, `# Memoria: ${topic}\n${entry}\n`, "utf-8");
         }
         // Update MEMORY.md index if not already present
-        const indexContent = fs.readFileSync(this.memoryIndexPath, "utf-8");
+        let indexContent = "";
+        if (fs.existsSync(indexPath)) {
+            indexContent = fs.readFileSync(indexPath, "utf-8");
+        }
         if (!indexContent.includes(`${sanitized}.md`)) {
             const link = `- [${topic}](./${sanitized}.md): Registro de ${topic}.\n`;
-            fs.appendFileSync(this.memoryIndexPath, link, "utf-8");
+            fs.appendFileSync(indexPath, link, "utf-8");
+        }
+        if (resolvedScope === "project") {
+            return `✔ Hecho guardado en memoria local de proyecto (.chocolatito/memory/${sanitized}.md).`;
+        }
+        else {
+            return `✔ Hecho guardado en memoria global (~/.chocolatito/memory/${sanitized}.md).`;
         }
-        return `✔ Hecho guardado en memoria persistente (~/.chocolatito/memory/${sanitized}.md).`;
     }
-    readMemory(topic) {
-        this.ensureDirectory();
-        const sanitized = topic.toLowerCase().replace(/[^a-z0-9_-]/g, "_");
-        const filePath = path.join(this.memoryDir, `${sanitized}.md`);
-        if (fs.existsSync(filePath)) {
-            return fs.readFileSync(filePath, "utf-8");
+    readMemory(topic, scope) {
+        const sanitized = this.sanitizeTopic(topic);
+        if (scope === "project") {
+            const pPath = path.join(this.getProjectDir(), `${sanitized}.md`);
+            if (fs.existsSync(pPath)) {
+                return fs.readFileSync(pPath, "utf-8");
+            }
+            return `No hay memoria registrada para el tema "${topic}" en el proyecto.`;
+        }
+        if (scope === "global") {
+            const gPath = path.join(this.getGlobalDir(), `${sanitized}.md`);
+            if (fs.existsSync(gPath)) {
+                return fs.readFileSync(gPath, "utf-8");
+            }
+            return `No hay memoria registrada para el tema "${topic}" en la memoria global.`;
+        }
+        // Sin scope especificado: buscar primero en proyecto, luego en global
+        const sameDir = this.isSamePath(this.getProjectDir(), this.getGlobalDir());
+        const pPath = path.join(this.getProjectDir(), `${sanitized}.md`);
+        const gPath = path.join(this.getGlobalDir(), `${sanitized}.md`);
+        const pExists = this.isProjectCwdValid() && fs.existsSync(pPath);
+        const gExists = !sameDir && fs.existsSync(gPath);
+        if (pExists && gExists) {
+            const pContent = fs.readFileSync(pPath, "utf-8").trim();
+            const gContent = fs.readFileSync(gPath, "utf-8").trim();
+            return `[Memoria de Proyecto]\n${pContent}\n\n[Memoria Global]\n${gContent}`;
+        }
+        if (pExists) {
+            return fs.readFileSync(pPath, "utf-8");
+        }
+        if (gExists || (sameDir && fs.existsSync(gPath))) {
+            return fs.readFileSync(gPath, "utf-8");
         }
         return `No hay memoria registrada para el tema "${topic}".`;
     }

package/dist/servidor/captura.d.ts

@@ -0,0 +1,36 @@
+/**
+ * LO QUE SE ESCRIBE, COPIADO PARA EL NAVEGADOR
+ *
+ * No se redirige nada: se COPIA. El terminal sigue recibiendo exactamente lo
+ * mismo que antes, porque quien arranca `--servir` normalmente lo deja abierto
+ * en su PC y lo mira desde ahi tambien. Si esto desviara la salida, el que esta
+ * delante de la maquina se quedaria sin ver su propia sesion.
+ *
+ * POR QUE SE ENVUELVE `console` Y NO `process.stdout`
+ *
+ * Ya esta decidido en ui/salida.ts y ui/pantalla.ts, y por las razones buenas:
+ * sustituir process.stdout hace desaparecer pruebas del informe de `node --test`
+ * sin que fallen. Aqui se envuelve console, que es otro objeto y no tiene ese
+ * problema.
+ *
+ * EL ORDEN IMPORTA, Y ES LA UNICA TRAMPA DE ESTE ARCHIVO
+ *
+ * ui/pantalla.ts:144 ya reemplaza los cuatro canales para mandarlos a la
+ * transcripcion de Ink. Esto tiene que envolverse DESPUES de eso: asi lo que se
+ * llama es la version de pantalla (el terminal sigue pintando) y de paso se
+ * copia. Al reves, pantalla envolveria a esto y la copia no se enteraria de
+ * nada. Por eso en index.ts la captura arranca despues de entrarEnPantallaFija.
+ */
+export interface LineaWeb {
+    /** Estable y creciente. El navegador lo usa para no repetir lineas al reconectar. */
+    id: number;
+    texto: string;
+}
+/** Mete una linea propia (avisos del servidor, eco de lo que llega del movil). */
+export declare function anotarWeb(texto: string): void;
+export declare function iniciarCaptura(): void;
+export declare function detenerCaptura(): void;
+export declare function historialWeb(desde?: number): LineaWeb[];
+export declare function alEscribirWeb(cb: (linea: LineaWeb) => void): () => void;
+/** Solo para pruebas: deja el modulo como recien cargado. */
+export declare function vaciarCaptura(): void;

package/dist/servidor/captura.js

@@ -0,0 +1,74 @@
+import { format } from "node:util";
+const CANALES = ["log", "error", "warn", "info"];
+/**
+ * Tope del historial. Es para el que abre el movil a mitad de sesion y quiere
+ * contexto, no un registro completo: eso ya lo tiene el terminal de verdad.
+ */
+const MAX_LINEAS = 1_000;
+let lineas = [];
+let siguienteId = 1;
+const oyentes = new Set();
+const previos = new Map();
+/** Reentrada: si un oyente escribe por consola, no se vuelve a capturar. */
+let dentro = false;
+function guardar(texto) {
+    for (const trozo of texto.replace(/\r\n/g, "\n").split("\n")) {
+        const linea = { id: siguienteId++, texto: trozo };
+        lineas.push(linea);
+        if (lineas.length > MAX_LINEAS)
+            lineas = lineas.slice(-MAX_LINEAS);
+        for (const cb of oyentes) {
+            try {
+                cb(linea);
+            }
+            catch {
+                // Un cliente que se cae no puede tumbar la salida de la sesion.
+            }
+        }
+    }
+}
+/** Mete una linea propia (avisos del servidor, eco de lo que llega del movil). */
+export function anotarWeb(texto) {
+    guardar(texto);
+}
+export function iniciarCaptura() {
+    if (previos.size)
+        return;
+    for (const nombre of CANALES) {
+        const previo = console[nombre].bind(console);
+        previos.set(nombre, previo);
+        console[nombre] = (...args) => {
+            previo(...args);
+            if (dentro)
+                return;
+            dentro = true;
+            try {
+                guardar(format(...args));
+            }
+            finally {
+                dentro = false;
+            }
+        };
+    }
+}
+export function detenerCaptura() {
+    for (const nombre of CANALES) {
+        const previo = previos.get(nombre);
+        if (previo)
+            console[nombre] = previo;
+    }
+    previos.clear();
+}
+export function historialWeb(desde = 0) {
+    return desde ? lineas.filter((l) => l.id > desde) : lineas.slice();
+}
+export function alEscribirWeb(cb) {
+    oyentes.add(cb);
+    return () => oyentes.delete(cb);
+}
+/** Solo para pruebas: deja el modulo como recien cargado. */
+export function vaciarCaptura() {
+    lineas = [];
+    siguienteId = 1;
+    oyentes.clear();
+}

package/dist/servidor/pagina.d.ts

@@ -0,0 +1,27 @@
+/**
+ * LA PAGINA, ENTERA Y SIN DEPENDENCIAS
+ *
+ * Nada de CDN: ni una fuente, ni una libreria. Tres razones y las tres pesan.
+ * Corre en tu red local, donde puede no haber salida a internet; un CDN veria la
+ * direccion desde la que entra cada sesion de cada cliente; y una pagina que
+ * depende de un tercero se rompe el dia que el tercero cambia algo.
+ *
+ * ESTA PENSADA PARA UN MOVIL, Y ESO SON DECISIONES CONCRETAS
+ *
+ *  - La caja de escribir tiene font-size 16px. Por debajo de 16, Safari de iOS
+ *    hace zoom solo al enfocar el campo y descoloca la pagina entera. Es la
+ *    razon de ese numero y no otro.
+ *  - `env(safe-area-inset-bottom)`: sin eso, en un iPhone la barra de escribir
+ *    queda debajo de la raya del gesto de inicio.
+ *  - `dvh` y no `vh`: con `vh`, al abrirse el teclado la pagina sigue midiendo
+ *    la pantalla entera y el campo se va hacia abajo, fuera de la vista.
+ *  - Se reconecta sola, con espera creciente. Un movil pierde la red a cada rato,
+ *    y una sesion que hay que recargar a mano no se usa dos veces.
+ *
+ * EL COLOR SALE DEL ANSI DE VERDAD
+ *
+ * La transcripcion llega tal cual, con los codigos de chalk dentro. Se traducen
+ * aqui a `<span>` en vez de quitarlos: el diff en verde y rojo ES el producto, y
+ * un diff en gris no vende nada.
+ */
+export declare function paginaHtml(): string;