chocolatito-code 1.0.0

package/dist/ui/permissionPrompt.js

@@ -0,0 +1,271 @@
+import readline from "node:readline";
+import process from "node:process";
+import chalk from "chalk";
+import { cycleMode, describeMode, getMode, modeAnnouncement } from "./modes.js";
+/**
+ * Aprobacion automatica: se activa con --yes / -y o con la variable de entorno
+ * CHOCOLATITO_AUTO_APPROVE. Pensada para modo no interactivo y CI.
+ */
+let autoApprove = process.env.CHOCOLATITO_AUTO_APPROVE === "1";
+export function setAutoApprove(value) {
+    autoApprove = value;
+}
+/**
+ * DIALOGO DE PERMISO
+ *
+ * La version anterior tenia dos fallos visibles en cuanto se usaba:
+ *
+ *  1. Al mover la seleccion subia el cursor 12 lineas fijas, pero la caja mide
+ *     entre 10 y 14 segun cuantos detalles tenga. Cada flecha dejaba media caja
+ *     huerfana en pantalla, y por eso salian marcos vacios apilados.
+ *
+ *  2. El titulo llevaba un simbolo de anchura ambigua. El terminal lo pinta
+ *     ocupando dos columnas y el calculo del ancho contaba una, asi que el borde
+ *     derecho quedaba descuadrado justo en esa linea.
+ *
+ * Aqui se dibuja la caja a mano, con anchura conocida, y se repinta subiendo
+ * exactamente las lineas que se escribieron.
+ */
+export async function askToolPermission(toolName, args, cwd = process.cwd()) {
+    if (autoApprove) {
+        return { approved: true };
+    }
+    // Sin terminal interactiva no hay nadie que pueda contestar. Antes el agente
+    // se quedaba colgado para siempre esperando una tecla que nunca llegaba, y en
+    // modo `chocolatito "tarea"` o en CI eso es un bloqueo silencioso. Ante la
+    // duda se deniega, que es lo seguro, y se explica como autorizar.
+    if (!process.stdin.isTTY) {
+        return {
+            approved: false,
+            userFeedback: `No hay terminal interactiva para pedir permiso de "${toolName}". ` +
+                `Vuelve a lanzarlo con --yes (o CHOCOLATITO_AUTO_APPROVE=1) si quieres aprobar automaticamente, ` +
+                `o ejecuta el comando tu mismo.`,
+        };
+    }
+    return new Promise((resolve) => {
+        let selectedIndex = 0;
+        const options = PERMISSION_OPTIONS;
+        const kind = classify(toolName, args);
+        const width = boxWidth();
+        const wasRaw = process.stdin.isRaw;
+        if (process.stdin.setRawMode)
+            process.stdin.setRawMode(true);
+        process.stdin.resume();
+        /** Lineas que ocupa el ultimo dibujo, para poder repintarlo sin dejar restos. */
+        let renderedRows = 0;
+        function draw() {
+            if (renderedRows > 0) {
+                // Se sube justo lo que se escribio: ni una linea mas, ni una menos.
+                process.stdout.write(`\x1b[${renderedRows}A`);
+            }
+            const lines = buildPermissionBox(toolName, args, cwd, selectedIndex, width);
+            // Cada linea se limpia antes de escribirse: si el dibujo anterior era mas
+            // ancho, no queda cola a la derecha.
+            process.stdout.write(lines.map((l) => `\r\x1b[2K${l}`).join("\n") + "\n");
+            renderedRows = lines.length;
+        }
+        draw();
+        function cleanup() {
+            process.stdin.removeListener("keypress", onKeypress);
+            if (process.stdin.setRawMode)
+                process.stdin.setRawMode(wasRaw || false);
+        }
+        async function promptForFeedback() {
+            cleanup();
+            return new Promise((resFeedback) => {
+                const rl = readline.createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                rl.question(chalk.hex("#A855F7")("\n¿Qué prefieres que haga? ❯ "), (answer) => {
+                    rl.close();
+                    resFeedback(answer.trim() || "El usuario canceló la acción sin dar detalles adicionales.");
+                });
+            });
+        }
+        async function onKeypress(str, key) {
+            // Shift+Tab desde el propio dialogo: cambia de modo instantáneamente
+            const isShiftTab = Boolean(key && key.name === "tab" && key.shift) ||
+                str === "\x1b[Z" ||
+                Boolean(key && key.sequence === "\x1b[Z");
+            if (isShiftTab) {
+                const nuevo = cycleMode();
+                if (nuevo === "bypass") {
+                    cleanup();
+                    process.stdout.write(`\r\x1b[2K${modeAnnouncement(nuevo)}\n`);
+                    resolve({ approved: true });
+                    return;
+                }
+                process.stdout.write(`\r\x1b[2K${modeAnnouncement(nuevo)}\n`);
+                renderedRows = 0;
+                draw();
+                return;
+            }
+            if (key && (key.name === "return" || key.name === "enter")) {
+                if (selectedIndex === 0) {
+                    cleanup();
+                    resolve({ approved: true });
+                }
+                else if (selectedIndex === 1) {
+                    cleanup();
+                    resolve({ approved: true, rememberPattern: true });
+                }
+                else {
+                    const feedback = await promptForFeedback();
+                    resolve({ approved: false, userFeedback: feedback });
+                }
+                return;
+            }
+            if (key && key.name === "escape") {
+                cleanup();
+                resolve({ approved: false, userFeedback: "Cancelado por el usuario con la tecla Esc." });
+                return;
+            }
+            if (str === "1") {
+                cleanup();
+                resolve({ approved: true });
+                return;
+            }
+            if (str === "2") {
+                cleanup();
+                resolve({ approved: true, rememberPattern: true });
+                return;
+            }
+            if (str === "3") {
+                const feedback = await promptForFeedback();
+                resolve({ approved: false, userFeedback: feedback });
+                return;
+            }
+            if (key && (key.name === "up" || key.name === "down")) {
+                const delta = key.name === "up" ? -1 : 1;
+                selectedIndex = (selectedIndex + delta + options.length) % options.length;
+                draw();
+                return;
+            }
+            if (key && key.ctrl && key.name === "c") {
+                cleanup();
+                process.stdout.write("\n");
+                process.exit(0);
+            }
+        }
+        process.stdin.on("keypress", onKeypress);
+    });
+}
+// ---------------------------------------------------------------------------
+// Dibujo de la caja.
+//
+// Se hace a mano en vez de con una libreria porque hay que saber con exactitud
+// cuantas lineas ocupa y cuanto mide el texto sin los codigos de color. Los
+// simbolos usados son de anchura fija: nada de emoji, que es lo que descuadraba
+// el borde derecho.
+const H = "─";
+export const PERMISSION_OPTIONS = [
+    { label: "Sí, adelante", hint: "solo esta vez" },
+    { label: "Sí, y no preguntar más por esto", hint: "lo recuerda en este proyecto" },
+    { label: "No, prefiero decirte otra cosa", hint: "cancela y te lo explico" },
+];
+/**
+ * Construye el dialogo entero como lista de lineas.
+ *
+ * Es una funcion pura a proposito: asi se puede comprobar en una prueba que
+ * todas las lineas del marco miden exactamente lo mismo. El descuadre del borde
+ * derecho no se ve leyendo el codigo, solo ejecutandolo.
+ */
+export function buildPermissionBox(toolName, args, cwd, selectedIndex, width = boxWidth()) {
+    const kind = classify(toolName, args);
+    const lines = [];
+    lines.push(top(width, kind.color));
+    lines.push(row(chalk.bold.hex(kind.color)(kind.title), width, kind.color, kind.title.length));
+    for (const d of details(toolName, args, cwd, width)) {
+        lines.push(row(d.text, width, kind.color, d.length));
+    }
+    PERMISSION_OPTIONS.forEach((opt, idx) => {
+        const sel = idx === selectedIndex;
+        const marker = sel ? "❯" : " ";
+        const num = `${idx + 1}.`;
+        const cabeza = `  ${marker} ${num} ${opt.label}`;
+        // La pista es lo primero que se cae si no cabe: perder el marco por una
+        // aclaración opcional es peor que quedarse sin la aclaración.
+        const conPista = `${cabeza}  ${opt.hint}`;
+        const cabe = conPista.length <= width - 3;
+        const plain = cabe ? conPista : cabeza;
+        const etiqueta = sel ? chalk.bold.white(opt.label) : chalk.gray(opt.label);
+        const flecha = sel ? chalk.hex(kind.color)(marker) : marker;
+        const painted = `  ${flecha} ${chalk.gray(num)} ${etiqueta}${cabe ? `  ${chalk.gray(opt.hint)}` : ""}`;
+        lines.push(row(painted, width, kind.color, plain.length));
+    });
+    lines.push(bottom(width, kind.color));
+    const modo = describeMode(getMode());
+    lines.push(chalk.gray("  ↑↓ o 1-3 · enter confirma · esc cancela · ") +
+        chalk.hex(modo.color)("shift+tab") +
+        chalk.gray(" cambia a modo automático"));
+    return lines;
+}
+function boxWidth() {
+    const cols = process.stdout.columns || 80;
+    return Math.max(48, Math.min(96, cols - 4));
+}
+function top(width, color) {
+    return chalk.hex(color)(`╭${H.repeat(width - 2)}╮`);
+}
+function bottom(width, color) {
+    return chalk.hex(color)(`╰${H.repeat(width - 2)}╯`);
+}
+/** Una fila del marco. `plainLength` es el ancho real del texto ya pintado. */
+function row(painted, width, color, plainLength) {
+    const inner = width - 2;
+    const relleno = Math.max(0, inner - plainLength);
+    const bar = chalk.hex(color)("│");
+    return `${bar}${painted}${" ".repeat(relleno)}${bar}`;
+}
+function classify(toolName, args) {
+    if (toolName === "delete_file")
+        return { title: "  Borrar un archivo", color: "#EF4444" };
+    if (toolName === "run_command")
+        return { title: "  Ejecutar un comando", color: "#F59E0B" };
+    if (toolName === "edit_file" || toolName === "write_file") {
+        return { title: "  Escribir en un archivo", color: "#D97757" };
+    }
+    if (toolName === "move_copy_file")
+        return { title: "  Mover o copiar un archivo", color: "#D97757" };
+    if (toolName === "chrome" || toolName === "browser" || toolName === "browser_live") {
+        return { title: "  Controlar tu navegador", color: "#A855F7" };
+    }
+    if (toolName === "computer_use")
+        return { title: "  Controlar tu ordenador", color: "#A855F7" };
+    return { title: "  Permiso de ejecución", color: "#D97757" };
+}
+/** Las lineas de detalle, ya recortadas para que quepan dentro del marco. */
+function details(toolName, args, cwd, width) {
+    const max = width - 8;
+    const out = [];
+    const add = (plain, painted) => {
+        const corto = plain.length > max ? `${plain.slice(0, max - 1)}…` : plain;
+        const texto = painted && plain.length <= max ? painted : chalk.white(corto);
+        out.push({ text: `  ${texto}`, length: corto.length + 2 });
+    };
+    out.push({ text: "", length: 0 });
+    if (typeof args.command === "string") {
+        add(args.command, chalk.bold.white(args.command));
+        add(`en ${cwd}`, chalk.gray(`en ${cwd}`));
+    }
+    else if (typeof args.path === "string") {
+        add(args.path, chalk.bold.white(args.path));
+        if (typeof args.oldText === "string" && typeof args.newText === "string") {
+            const mas = args.newText.split("\n").length;
+            const menos = args.oldText.split("\n").length;
+            const plain = `+${mas} líneas  -${menos} líneas`;
+            add(plain, `${chalk.green(`+${mas} líneas`)}  ${chalk.red(`-${menos} líneas`)}`);
+        }
+    }
+    else if (typeof args.action === "string") {
+        const extra = args.url || args.appName || args.window || args.text || "";
+        const plain = extra ? `${args.action}  ${String(extra)}` : String(args.action);
+        add(plain, extra ? `${chalk.bold.white(args.action)}  ${chalk.gray(String(extra))}` : chalk.bold.white(args.action));
+    }
+    else {
+        add(toolName, chalk.bold.white(toolName));
+    }
+    out.push({ text: "", length: 0 });
+    return out;
+}

package/dist/ui/prompt.d.ts

@@ -0,0 +1,7 @@
+export interface SlashCommandItem {
+    name: string;
+    description: string;
+    args?: string;
+}
+export declare const SLASH_COMMANDS: SlashCommandItem[];
+export declare function askInteractivePrompt(promptSymbol?: string, cwd?: string): Promise<string>;