vipcode 0.0.0-stage → 0.2.1

package/dist/tui/dialogs.js

@@ -0,0 +1,197 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput, usePaste } from "ink";
+import { useMemo, useState } from "react";
+import { suggestPattern } from "../permissions.js";
+import { showControl, stripControl } from "../sanitize.js";
+import { colorPreview } from "../ui.js";
+import { EMPTY, backspace, deleteWordBack, insert, moveLeft, moveRight, splitEnter } from "./editor.js";
+const KIND_LABEL = {
+    write: "ediciones de ficheros",
+    bash: "comandos",
+    web: "accesos a internet",
+    mcp: "herramientas MCP",
+};
+// Pregunta antes de editar, ejecutar o salir a internet, enseñando el diff o el comando
+export function PermissionDialog(props) {
+    const { request } = props;
+    const pattern = request.kind === "bash" ? suggestPattern(request.subject) : "";
+    const options = [{ key: "s", label: "Sí" }];
+    options.push({ key: "t", label: `Sí, y no preguntar más por ${KIND_LABEL[request.kind] || "esto"} en esta sesión` });
+    if (pattern) {
+        options.push({ key: "p", label: `Sí, y permitir siempre «${pattern}» en esta sesión` });
+    }
+    options.push({ key: "n", label: "No" });
+    options.push({ key: "e", label: "No, y decirle qué hacer en su lugar" });
+    const [selected, setSelected] = useState(0);
+    const [explaining, setExplaining] = useState(false);
+    const [feedback, setFeedback] = useState(EMPTY);
+    const choose = (key) => {
+        if (key === "s") {
+            props.onDone({ reply: { allow: true } });
+        }
+        else if (key === "t") {
+            props.onDone({ reply: { allow: true }, grant: "kind" });
+        }
+        else if (key === "p") {
+            props.onDone({ reply: { allow: true }, grant: "pattern", pattern });
+        }
+        else if (key === "n") {
+            props.onDone({ reply: { allow: false } });
+        }
+        else if (key === "e") {
+            setExplaining(true);
+        }
+    };
+    useInput((input, key) => {
+        const { text, enter } = splitEnter(input, key.return);
+        if (explaining) {
+            if (enter) {
+                const value = insert(feedback, text).value;
+                props.onDone({ reply: { allow: false, feedback: value.trim() || undefined } });
+            }
+            else if (key.escape) {
+                setExplaining(false);
+            }
+            else if (key.backspace) {
+                setFeedback(backspace(feedback));
+            }
+            else if (key.leftArrow) {
+                setFeedback(moveLeft(feedback));
+            }
+            else if (key.rightArrow) {
+                setFeedback(moveRight(feedback));
+            }
+            else if (key.ctrl && input === "w") {
+                setFeedback(deleteWordBack(feedback));
+            }
+            else if (input && !key.ctrl && !key.meta) {
+                setFeedback(insert(feedback, input));
+            }
+            return;
+        }
+        const letter = text.trim().toLowerCase();
+        if (key.upArrow) {
+            setSelected((selected - 1 + options.length) % options.length);
+        }
+        else if (key.downArrow || key.tab) {
+            setSelected((selected + 1) % options.length);
+        }
+        else if (key.escape) {
+            choose("n");
+        }
+        else if (letter && options.some((option) => option.key === letter)) {
+            choose(letter);
+        }
+        else if (letter === "y") {
+            choose("s");
+        }
+        else if (enter) {
+            choose(options[selected].key);
+        }
+    });
+    usePaste((text) => {
+        if (explaining) {
+            setFeedback(insert(feedback, text.replace(/\r?\n/g, " ")));
+        }
+    });
+    const lines = request.preview.split("\n");
+    const shown = lines.slice(0, 30).join("\n");
+    const hidden = lines.length - 30;
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [_jsxs(Text, { bold: true, color: "yellow", children: ["? ", showControl(request.title), props.agent !== "build" ? _jsxs(Text, { dimColor: true, children: [" (", props.agent, ")"] }) : null] }), _jsxs(Box, { marginY: 1, flexDirection: "column", children: [_jsx(Text, { children: colorPreview(shown) }), hidden > 0 ? _jsxs(Text, { dimColor: true, children: ["\u2026 ", hidden, " l\u00EDneas m\u00E1s"] }) : null] }), explaining ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "\u00BFQu\u00E9 deber\u00EDa hacer en su lugar? (Enter env\u00EDa, Esc vuelve)" }), _jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: "\u276F " }), feedback.value.slice(0, feedback.cursor), _jsx(Text, { inverse: true, children: feedback.value[feedback.cursor] || " " }), feedback.value.slice(feedback.cursor + 1)] })] })) : (_jsxs(_Fragment, { children: [options.map((option, index) => (_jsxs(Text, { color: index === selected ? "cyan" : undefined, children: [index === selected ? "❯ " : "  ", _jsxs(Text, { dimColor: true, children: ["[", option.key, "]"] }), " ", option.label] }, option.key))), _jsx(Text, { dimColor: true, children: "\u2191\u2193 elige \u00B7 Enter acepta \u00B7 la letra es un atajo \u00B7 Esc = no" })] }))] }));
+}
+function matches(item, query) {
+    return `${item.label} ${item.description || ""}`.toLowerCase().includes(query);
+}
+// Lista para elegir (modelos, sesiones, agentes, proveedores); escribir filtra
+export function SelectDialog(props) {
+    const [filter, setFilter] = useState("");
+    const [selected, setSelected] = useState(0);
+    const filtered = useMemo(() => {
+        const query = filter.toLowerCase();
+        if (!query) {
+            return props.items;
+        }
+        return props.items.filter((item) => matches(item, query));
+    }, [filter, props.items]);
+    useInput((input, key) => {
+        const { text, enter } = splitEnter(input, key.return);
+        if (key.escape) {
+            props.onDone(null);
+        }
+        else if (enter) {
+            // Si el Enter vino pegado a texto, ese texto también filtra
+            let list = filtered;
+            let index = selected;
+            if (text) {
+                const query = (filter + text).toLowerCase();
+                list = props.items.filter((item) => matches(item, query));
+                index = 0;
+            }
+            const item = list[index];
+            props.onDone(item ? item.value : null);
+        }
+        else if (key.upArrow) {
+            setSelected(Math.max(0, selected - 1));
+        }
+        else if (key.downArrow || key.tab) {
+            setSelected(Math.min(filtered.length - 1, selected + 1));
+        }
+        else if (key.pageUp) {
+            setSelected(Math.max(0, selected - 10));
+        }
+        else if (key.pageDown) {
+            setSelected(Math.min(filtered.length - 1, selected + 10));
+        }
+        else if (key.backspace) {
+            setFilter(filter.slice(0, -1));
+            setSelected(0);
+        }
+        else if (input && !key.ctrl && !key.meta) {
+            setFilter(filter + input);
+            setSelected(0);
+        }
+    });
+    const windowSize = 12;
+    const start = Math.max(0, Math.min(selected - Math.floor(windowSize / 2), filtered.length - windowSize));
+    const visible = filtered.slice(start, start + windowSize);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: props.title }), _jsx(Text, { dimColor: true, children: filter ? `Filtro: ${filter}` : "Escribe para filtrar · ↑↓ elegir · Enter aceptar · Esc salir" }), visible.length === 0 ? _jsx(Text, { dimColor: true, children: "(nada coincide)" }) : null, visible.map((item, index) => {
+                const active = start + index === selected;
+                return (_jsxs(Text, { color: active ? "cyan" : undefined, wrap: "truncate-end", children: [active ? "❯ " : "  ", stripControl(item.label), item.description ? _jsxs(Text, { dimColor: true, children: [" ", stripControl(item.description)] }) : null] }, `${start + index}-${item.label}`));
+            }), filtered.length > windowSize ? (_jsxs(Text, { dimColor: true, children: [selected + 1, "/", filtered.length] })) : null] }));
+}
+// Pide un texto (las claves se ven como •••)
+export function PromptDialog(props) {
+    const [state, setState] = useState(EMPTY);
+    useInput((input, key) => {
+        const { text, enter } = splitEnter(input, key.return);
+        if (key.escape) {
+            props.onDone(null);
+        }
+        else if (enter) {
+            props.onDone(insert(state, text).value);
+        }
+        else if (key.backspace) {
+            setState(backspace(state));
+        }
+        else if (key.leftArrow) {
+            setState(moveLeft(state));
+        }
+        else if (key.rightArrow) {
+            setState(moveRight(state));
+        }
+        else if (key.ctrl && input === "u") {
+            setState(EMPTY);
+        }
+        else if (input && !key.ctrl && !key.meta) {
+            setState(insert(state, input));
+        }
+    });
+    usePaste((text) => {
+        setState(insert(state, text.replace(/\r?\n/g, "").trim()));
+    });
+    let shown = state.value;
+    if (props.mask) {
+        shown = "•".repeat(state.value.length);
+    }
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "magenta", paddingX: 1, children: [_jsx(Text, { bold: true, color: "magenta", children: props.title }), _jsxs(Text, { children: [_jsx(Text, { color: "magenta", children: "\u276F " }), shown.length === 0 && props.placeholder ? _jsx(Text, { dimColor: true, children: props.placeholder }) : null, shown.slice(0, state.cursor), _jsx(Text, { inverse: true, children: shown[state.cursor] || " " }), shown.slice(state.cursor + 1)] }), _jsxs(Text, { dimColor: true, children: ["Enter acepta \u00B7 Esc cancela", props.mask ? " · pega la clave con Cmd+V" : ""] })] }));
+}

package/dist/tui/editor.js

@@ -0,0 +1,120 @@
+// Edición del cuadro de texto: funciones puras sobre el texto y la posición del cursor
+export const EMPTY = { value: "", cursor: 0 };
+export function insert(state, text) {
+    const value = state.value.slice(0, state.cursor) + text + state.value.slice(state.cursor);
+    return { value, cursor: state.cursor + text.length };
+}
+export function backspace(state) {
+    if (state.cursor === 0) {
+        return state;
+    }
+    return { value: state.value.slice(0, state.cursor - 1) + state.value.slice(state.cursor), cursor: state.cursor - 1 };
+}
+export function deleteForward(state) {
+    if (state.cursor >= state.value.length) {
+        return state;
+    }
+    return { value: state.value.slice(0, state.cursor) + state.value.slice(state.cursor + 1), cursor: state.cursor };
+}
+function isWordChar(char) {
+    return /[\p{L}\p{N}_]/u.test(char);
+}
+function wordStart(value, cursor) {
+    let i = cursor;
+    while (i > 0 && !isWordChar(value[i - 1])) {
+        i--;
+    }
+    while (i > 0 && isWordChar(value[i - 1])) {
+        i--;
+    }
+    return i;
+}
+function wordEnd(value, cursor) {
+    let i = cursor;
+    while (i < value.length && !isWordChar(value[i])) {
+        i++;
+    }
+    while (i < value.length && isWordChar(value[i])) {
+        i++;
+    }
+    return i;
+}
+export function moveLeft(state, word = false) {
+    if (word) {
+        return { ...state, cursor: wordStart(state.value, state.cursor) };
+    }
+    return { ...state, cursor: Math.max(0, state.cursor - 1) };
+}
+export function moveRight(state, word = false) {
+    if (word) {
+        return { ...state, cursor: wordEnd(state.value, state.cursor) };
+    }
+    return { ...state, cursor: Math.min(state.value.length, state.cursor + 1) };
+}
+export function deleteWordBack(state) {
+    const start = wordStart(state.value, state.cursor);
+    return { value: state.value.slice(0, start) + state.value.slice(state.cursor), cursor: start };
+}
+function lineBounds(value, cursor) {
+    const start = value.lastIndexOf("\n", cursor - 1) + 1;
+    let end = value.indexOf("\n", cursor);
+    if (end < 0) {
+        end = value.length;
+    }
+    return { start, end };
+}
+export function lineStart(state) {
+    return { ...state, cursor: lineBounds(state.value, state.cursor).start };
+}
+export function lineEnd(state) {
+    return { ...state, cursor: lineBounds(state.value, state.cursor).end };
+}
+export function deleteToLineStart(state) {
+    const { start } = lineBounds(state.value, state.cursor);
+    return { value: state.value.slice(0, start) + state.value.slice(state.cursor), cursor: start };
+}
+export function deleteToLineEnd(state) {
+    const { end } = lineBounds(state.value, state.cursor);
+    return { value: state.value.slice(0, state.cursor) + state.value.slice(end), cursor: state.cursor };
+}
+export function cursorPosition(state) {
+    const before = state.value.slice(0, state.cursor);
+    const line = before.split("\n").length - 1;
+    const column = before.length - (before.lastIndexOf("\n") + 1);
+    return { line, column, lines: state.value.split("\n") };
+}
+// Sube o baja una línea; devuelve null si ya está en la primera/última (entonces se usa el historial)
+export function moveVertical(state, direction) {
+    const { line, column, lines } = cursorPosition(state);
+    const target = line + direction;
+    if (target < 0 || target >= lines.length) {
+        return null;
+    }
+    let offset = 0;
+    for (let i = 0; i < target; i++) {
+        offset += lines[i].length + 1;
+    }
+    return { ...state, cursor: offset + Math.min(column, lines[target].length) };
+}
+// La palabra @… que se está escribiendo justo antes del cursor
+export function mentionAtCursor(state) {
+    const before = state.value.slice(0, state.cursor);
+    const match = /(^|\s)@([^\s@]*)$/.exec(before);
+    if (!match) {
+        return null;
+    }
+    return { start: before.length - match[2].length - 1, text: match[2] };
+}
+// Algunas terminales mandan "texto + Enter" en un solo bloque (o Enter como \n): separa el texto del Enter final
+export function splitEnter(input, isReturn) {
+    if (isReturn) {
+        return { text: "", enter: true };
+    }
+    if (/[\r\n]$/.test(input) && !/[\r\n]/.test(input.slice(0, -1))) {
+        return { text: input.slice(0, -1), enter: true };
+    }
+    return { text: input, enter: false };
+}
+export function replaceRange(state, start, end, text) {
+    return { value: state.value.slice(0, start) + text + state.value.slice(end), cursor: start + text.length };
+}

package/dist/ui.js

@@ -0,0 +1,184 @@
+import pc from "picocolors";
+import { suggestPattern } from "./permissions.js";
+import { showControl, stripControl, stripUnsafe } from "./sanitize.js";
+import { formatTodos } from "./tools.js";
+export const ui = {
+    text(chunk) {
+        process.stdout.write(chunk);
+    },
+    // Los mensajes pueden llevar texto de los proveedores o del modelo: sin secuencias de la terminal
+    info(message) {
+        console.log(pc.dim(stripUnsafe(message)));
+    },
+    notice(message) {
+        console.log(pc.yellow(`⚠ ${stripUnsafe(message)}`));
+    },
+    error(message) {
+        console.log(pc.red(`✖ ${stripUnsafe(message)}`));
+    },
+    tool(name, summary, depth = 0) {
+        const indent = depth > 0 ? "      " : "  ";
+        console.log(pc.cyan(`${indent}● ${showControl(name)}`) + pc.dim(` ${showControl(summary)}`));
+    },
+    banner(agent, slots) {
+        console.log(pc.bold(pc.magenta("vipcode")) + pc.dim(` · agente ${agent} · ${slots} modelos · /help para ayuda`));
+    },
+    prompt(agent) {
+        if (agent === "plan") {
+            return pc.blue("plan ❯ ");
+        }
+        if (agent !== "build") {
+            return pc.yellow(`${agent} ❯ `);
+        }
+        return pc.magenta("❯ ");
+    },
+};
+// Líneas quitadas en rojo, añadidas en verde, cabeceras @@ en cian y el contexto atenuado.
+// Es lo que apruebas: los caracteres de control se ven (␛) en vez de actuar
+export function colorPreview(preview) {
+    return showControl(preview)
+        .split("\n")
+        .map((line) => {
+        if (line.startsWith("+ ")) {
+            return pc.green(line);
+        }
+        if (line.startsWith("- ")) {
+            return pc.red(line);
+        }
+        if (line.startsWith("@@")) {
+            return pc.cyan(line);
+        }
+        if (line.startsWith("  ")) {
+            return pc.dim(line);
+        }
+        return line;
+    })
+        .join("\n");
+}
+function indent(text, prefix) {
+    return text
+        .split("\n")
+        .map((line) => prefix + line)
+        .join("\n");
+}
+// Eventos del agente pintados como texto normal
+export function plainEvents(options) {
+    let reasoning = "";
+    let reasoningShown = false;
+    const flushReasoning = () => {
+        if (reasoningShown) {
+            process.stdout.write("\n");
+        }
+        reasoning = "";
+        reasoningShown = false;
+    };
+    return {
+        onText: (chunk, depth) => {
+            if (depth > 0) {
+                return;
+            }
+            flushReasoning();
+            process.stdout.write(stripControl(chunk));
+        },
+        onTextEnd: (depth) => {
+            if (depth === 0) {
+                process.stdout.write("\n");
+            }
+        },
+        onReasoning: (chunk, depth) => {
+            if (!options.showReasoning || depth > 0) {
+                return;
+            }
+            // Solo el principio del razonamiento, en una línea atenuada
+            if (reasoning.length < 240) {
+                if (!reasoningShown) {
+                    process.stdout.write(pc.dim("  💭 "));
+                    reasoningShown = true;
+                }
+                const piece = stripControl(chunk).replace(/\s+/g, " ").slice(0, 240 - reasoning.length);
+                reasoning += piece;
+                process.stdout.write(pc.dim(piece));
+                if (reasoning.length >= 240) {
+                    process.stdout.write(pc.dim("…"));
+                }
+            }
+        },
+        onToolStart: (event) => {
+            flushReasoning();
+            ui.tool(event.name, event.summary, event.depth);
+        },
+        onToolEnd: (event) => {
+            const pad = event.depth > 0 ? "        " : "    ";
+            if (event.isError) {
+                console.log(pc.red(`${pad}${stripControl(event.output.split("\n")[0]).slice(0, 200)}`));
+            }
+            else if (event.display && event.depth === 0) {
+                console.log(indent(colorPreview(event.display), pad));
+            }
+        },
+        onNotice: (message) => {
+            flushReasoning();
+            ui.notice(message);
+        },
+        onInfo: (message) => ui.info(message),
+        onTodos: (todos) => console.log(pc.dim(indent(formatTodos(todos), "    "))),
+    };
+}
+// Pregunta s/n/t (y p para comandos) antes de escribir ficheros o ejecutar comandos
+export function plainPermissionPrompt(getReadline, grants) {
+    return async (request) => {
+        const rl = getReadline();
+        if (!rl || !process.stdin.isTTY) {
+            return { allow: false, feedback: "no hay nadie para aprobarlo (usa --yolo o ajusta los permisos)" };
+        }
+        console.log("");
+        console.log(pc.bold(pc.yellow(`? ${showControl(request.title)}`)));
+        console.log(colorPreview(request.preview));
+        let options = "[s]í / [n]o / [t]odo en esta sesión / [e] no y explicar";
+        let pattern = "";
+        if (request.kind === "bash") {
+            pattern = suggestPattern(request.subject);
+            options = `[s]í / [n]o / [t]odo / [p] siempre «${pattern}» / [e] no y explicar`;
+        }
+        while (true) {
+            let answer = "";
+            try {
+                answer = (await rl.question(pc.yellow(`  ¿Permitir? ${options}: `))).trim().toLowerCase();
+            }
+            catch {
+                return { allow: false, feedback: "sin respuesta" };
+            }
+            if (["s", "si", "sí", "y", "yes"].includes(answer)) {
+                return { allow: true };
+            }
+            if (answer === "n" || answer === "no") {
+                return { allow: false };
+            }
+            if (answer === "t") {
+                grants().allowKind(request.kind);
+                return { allow: true };
+            }
+            if (answer === "p" && pattern) {
+                grants().allowPattern("bash", pattern);
+                return { allow: true };
+            }
+            if (answer === "e") {
+                let why = "";
+                try {
+                    why = (await rl.question(pc.yellow("  ¿Qué debería hacer en su lugar?: "))).trim();
+                }
+                catch {
+                    why = "";
+                }
+                return { allow: false, feedback: why || undefined };
+            }
+        }
+    };
+}
+// Interfaz mínima para los comandos / en el modo de texto
+export const plainAdapter = {
+    info: (text) => ui.info(text),
+    notice: (text) => ui.notice(text),
+    error: (text) => ui.error(text),
+    block: (text) => console.log(stripUnsafe(text)),
+};