vipcode 0.0.0-stage → 0.2.1

package/dist/markdown.js

@@ -0,0 +1,262 @@
+import hljs from "highlight.js/lib/common";
+import { marked } from "marked";
+import pc from "picocolors";
+import { stripControl } from "./sanitize.js";
+// Colores de resaltado de código por clase de highlight.js
+const CODE_COLORS = {
+    keyword: pc.magenta,
+    built_in: pc.cyan,
+    type: pc.cyan,
+    literal: pc.blue,
+    number: pc.yellow,
+    string: pc.green,
+    regexp: pc.red,
+    comment: pc.gray,
+    doctag: pc.gray,
+    meta: pc.gray,
+    function: pc.blue,
+    title: pc.blue,
+    "title.class": pc.yellow,
+    "title.function": pc.blue,
+    params: (text) => text,
+    attr: pc.yellow,
+    attribute: pc.yellow,
+    variable: pc.red,
+    "variable.language": pc.magenta,
+    tag: pc.red,
+    name: pc.red,
+    "selector-tag": pc.red,
+    "selector-class": pc.yellow,
+    "selector-id": pc.yellow,
+    symbol: pc.yellow,
+    bullet: pc.yellow,
+    section: pc.bold,
+    addition: pc.green,
+    deletion: pc.red,
+    emphasis: pc.italic,
+    strong: pc.bold,
+    property: pc.cyan,
+    operator: (text) => text,
+    punctuation: (text) => text,
+    subst: (text) => text,
+};
+function decodeHtml(text) {
+    return text
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#x27;/g, "'")
+        .replace(/&#39;/g, "'")
+        .replace(/&amp;/g, "&");
+}
+// highlight.js devuelve HTML con <span class="hljs-…">; lo convertimos en colores de terminal
+function htmlToAnsi(html) {
+    const stack = [];
+    let out = "";
+    const pattern = /<span class="([^"]+)">|<\/span>|([^<]+)/g;
+    let match;
+    while ((match = pattern.exec(html)) !== null) {
+        if (match[1] !== undefined) {
+            stack.push(match[1].replace(/hljs-/g, "").split(" ")[0]);
+        }
+        else if (match[0] === "</span>") {
+            stack.pop();
+        }
+        else if (match[2] !== undefined) {
+            const text = decodeHtml(match[2]);
+            let colored = text;
+            for (let i = stack.length - 1; i >= 0; i--) {
+                const color = CODE_COLORS[stack[i]] || CODE_COLORS[stack[i].split(".")[0]];
+                if (color) {
+                    colored = color(text);
+                    break;
+                }
+            }
+            out += colored;
+        }
+    }
+    return out;
+}
+export function highlightCode(code, lang) {
+    const language = (lang || "").trim().split(/\s+/)[0].toLowerCase();
+    if (language && hljs.getLanguage(language)) {
+        try {
+            return htmlToAnsi(hljs.highlight(code, { language, ignoreIllegals: true }).value);
+        }
+        catch {
+            // si falla, sin colores
+        }
+    }
+    return code;
+}
+function inline(tokens) {
+    if (!tokens) {
+        return "";
+    }
+    let out = "";
+    for (const token of tokens) {
+        switch (token.type) {
+            case "strong":
+                out += pc.bold(inline(token.tokens));
+                break;
+            case "em":
+                out += pc.italic(inline(token.tokens));
+                break;
+            case "del":
+                out += pc.strikethrough(inline(token.tokens));
+                break;
+            case "codespan":
+                out += pc.cyan(decodeHtml(token.text));
+                break;
+            case "link": {
+                const link = token;
+                const text = inline(link.tokens);
+                if (text === link.href || link.href.startsWith("mailto:")) {
+                    out += pc.underline(pc.blue(text));
+                }
+                else {
+                    out += `${pc.underline(pc.blue(text))} ${pc.dim(`(${link.href})`)}`;
+                }
+                break;
+            }
+            case "image":
+                out += pc.dim(`[imagen: ${token.text || token.href}]`);
+                break;
+            case "br":
+                out += "\n";
+                break;
+            case "escape":
+                out += token.text;
+                break;
+            case "text": {
+                const text = token;
+                if (text.tokens && text.tokens.length > 0) {
+                    out += inline(text.tokens);
+                }
+                else {
+                    out += decodeHtml(text.text);
+                }
+                break;
+            }
+            case "html":
+                out += token.text;
+                break;
+            default:
+                out += decodeHtml(token.raw || "");
+        }
+    }
+    return out;
+}
+function indent(text, prefix) {
+    return text
+        .split("\n")
+        .map((line) => prefix + line)
+        .join("\n");
+}
+function renderList(list, width, depth) {
+    const lines = [];
+    let number = typeof list.start === "number" ? list.start : 1;
+    for (const item of list.items) {
+        let bullet = "•";
+        if (list.ordered) {
+            bullet = `${number}.`;
+            number++;
+        }
+        if (item.task) {
+            bullet = item.checked ? pc.green("☑") : "☐";
+        }
+        const body = blocks(item.tokens, width - 3, depth + 1).replace(/^\n+|\n+$/g, "");
+        const [first, ...rest] = body.split("\n");
+        const pad = " ".repeat(bullet.length + 1);
+        lines.push(`${pc.yellow(bullet)} ${first || ""}`);
+        for (const line of rest) {
+            lines.push(pad + line);
+        }
+    }
+    return lines.join("\n");
+}
+function renderTable(table) {
+    const header = table.header.map((cell) => inline(cell.tokens));
+    const rows = table.rows.map((row) => row.map((cell) => inline(cell.tokens)));
+    const visible = (text) => text.replace(/\x1b\[[0-9;]*m/g, "").length;
+    const widths = header.map((cell, i) => Math.max(visible(cell), ...rows.map((row) => visible(row[i] || ""))));
+    const pad = (text, width) => text + " ".repeat(Math.max(0, width - visible(text)));
+    const line = (cells) => cells.map((cell, i) => pad(cell, widths[i])).join(pc.dim(" │ "));
+    const out = [pc.bold(line(header)), pc.dim(widths.map((w) => "─".repeat(w)).join("─┼─"))];
+    for (const row of rows) {
+        out.push(line(row));
+    }
+    return out.join("\n");
+}
+function blocks(tokens, width, depth = 0) {
+    const out = [];
+    for (const token of tokens) {
+        switch (token.type) {
+            case "heading": {
+                const heading = token;
+                const text = inline(heading.tokens);
+                if (heading.depth === 1) {
+                    out.push(pc.bold(pc.underline(pc.magenta(text))));
+                }
+                else if (heading.depth === 2) {
+                    out.push(pc.bold(pc.cyan(text)));
+                }
+                else {
+                    out.push(pc.bold(text));
+                }
+                break;
+            }
+            case "paragraph":
+                out.push(inline(token.tokens));
+                break;
+            case "text": {
+                const text = token;
+                out.push(text.tokens ? inline(text.tokens) : decodeHtml(text.text));
+                break;
+            }
+            case "code": {
+                const code = token;
+                const label = code.lang ? pc.dim(`─ ${code.lang} `) : pc.dim("─");
+                out.push(`${label}${pc.dim("─".repeat(Math.max(0, Math.min(width, 60) - (code.lang || "").length - 3)))}`);
+                out.push(indent(highlightCode(code.text, code.lang), "  "));
+                out.push(pc.dim("─".repeat(Math.min(width, 60))));
+                break;
+            }
+            case "blockquote":
+                out.push(indent(blocks(token.tokens, width - 2, depth), pc.dim("│ ")));
+                break;
+            case "list":
+                out.push(renderList(token, width, depth));
+                break;
+            case "table":
+                out.push(renderTable(token));
+                break;
+            case "hr":
+                out.push(pc.dim("─".repeat(Math.min(width, 60))));
+                break;
+            case "html":
+                out.push(token.text.trim());
+                break;
+            case "space":
+                break;
+            default:
+                out.push(token.raw || "");
+        }
+    }
+    if (depth > 0) {
+        return out.join("\n");
+    }
+    return out.join("\n\n");
+}
+// Markdown → texto con colores para la terminal
+export function renderMarkdown(text, width = 80) {
+    // El texto del modelo no puede llevar secuencias de la terminal: los colores los ponemos nosotros
+    const clean = stripControl(text);
+    try {
+        const tokens = marked.lexer(clean, { gfm: true });
+        return blocks(tokens, width).replace(/\n{3,}/g, "\n\n");
+    }
+    catch {
+        return clean;
+    }
+}

package/dist/match.js

@@ -0,0 +1,8 @@
+// Comparación con comodines: "*" vale cualquier cosa ("gemini/*", "npm run *", "github_*")
+export function wildcardToRegex(pattern) {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[\\s\\S]*");
+    return new RegExp(`^${escaped}$`);
+}
+export function wildcardMatch(pattern, text) {
+    return wildcardToRegex(pattern).test(text);
+}

package/dist/mcp.js

@@ -0,0 +1,225 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { debugLog } from "./debug.js";
+import { truncate } from "./tools.js";
+// Los nombres de herramienta solo admiten letras, números, _ y - (máximo 64)
+function sanitizeName(name) {
+    return name.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+}
+// Algunos proveedores (Gemini) rechazan palabras del JSON Schema que no conocen
+function cleanSchema(schema) {
+    if (Array.isArray(schema)) {
+        return schema.map(cleanSchema);
+    }
+    if (!schema || typeof schema !== "object") {
+        return schema;
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(schema)) {
+        if (["$schema", "$id", "$comment", "additionalProperties", "examples"].includes(key)) {
+            continue;
+        }
+        if (key === "properties" && value && typeof value === "object") {
+            const props = {};
+            for (const [prop, propSchema] of Object.entries(value)) {
+                props[prop] = cleanSchema(propSchema);
+            }
+            result[key] = props;
+        }
+        else {
+            result[key] = cleanSchema(value);
+        }
+    }
+    return result;
+}
+function toText(result) {
+    const parts = [];
+    const images = [];
+    for (const item of result?.content || []) {
+        if (item.type === "text") {
+            parts.push(item.text);
+        }
+        else if (item.type === "image" && item.data) {
+            images.push(`data:${item.mimeType || "image/png"};base64,${item.data}`);
+            parts.push("[imagen adjunta]");
+        }
+        else if (item.type === "resource") {
+            parts.push(item.resource?.text || `[recurso ${item.resource?.uri || ""}]`);
+        }
+        else if (item.type === "resource_link") {
+            parts.push(`[enlace ${item.uri}]`);
+        }
+        else {
+            parts.push(JSON.stringify(item));
+        }
+    }
+    if (parts.length === 0 && result?.structuredContent) {
+        parts.push(JSON.stringify(result.structuredContent, null, 2));
+    }
+    let output = parts.join("\n").trim();
+    if (output === "") {
+        output = "(sin salida)";
+    }
+    return { output, images };
+}
+// Conecta con los servidores MCP del config y ofrece sus herramientas al agente
+export class McpManager {
+    configs;
+    root;
+    servers = new Map();
+    constructor(configs, root) {
+        this.configs = configs;
+        this.root = root;
+        for (const [name, config] of Object.entries(configs || {})) {
+            this.servers.set(name, { name, state: config?.enabled === false ? "desactivado" : "conectando", tools: [] });
+        }
+    }
+    hasServers() {
+        return this.servers.size > 0;
+    }
+    // Conecta con todos a la vez; los que fallan se quedan en "error" sin parar el resto
+    async start(onChange) {
+        await Promise.allSettled([...this.servers.values()]
+            .filter((server) => server.state === "conectando")
+            .map(async (server) => {
+            try {
+                await this.connect(server, this.configs[server.name]);
+                server.state = "conectado";
+            }
+            catch (err) {
+                server.state = "error";
+                server.error = err.message;
+                debugLog("mcp", server.name, err);
+            }
+            onChange?.();
+        }));
+    }
+    async connect(server, config) {
+        const timeout = config.timeoutMs || 30000;
+        const client = new Client({ name: "vipcode", version: "0.2.0" });
+        const isRemote = config.type === "remote" || (!config.type && Boolean(config.url));
+        const withTimeout = (promise, what) => {
+            let timer;
+            const limit = new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error(`${what}: tiempo agotado`)), timeout);
+            });
+            // Sin limpiar el temporizador, el proceso no podría terminar hasta que venciera
+            return Promise.race([promise, limit]).finally(() => clearTimeout(timer));
+        };
+        if (isRemote) {
+            if (!config.url) {
+                throw new Error("falta la url del servidor remoto");
+            }
+            const url = new URL(config.url);
+            const requestInit = { headers: config.headers || {} };
+            try {
+                await withTimeout(client.connect(new StreamableHTTPClientTransport(url, { requestInit })), "conectar");
+            }
+            catch (err) {
+                // Servidores antiguos que solo hablan SSE
+                debugLog("mcp streamable falló, pruebo SSE", server.name, err);
+                const fallback = new Client({ name: "vipcode", version: "0.2.0" });
+                await withTimeout(fallback.connect(new SSEClientTransport(url, { requestInit })), "conectar (SSE)");
+                server.client = fallback;
+            }
+        }
+        else {
+            let command = [];
+            if (Array.isArray(config.command)) {
+                command = config.command.map(String);
+            }
+            else if (typeof config.command === "string") {
+                command = [config.command];
+            }
+            command = [...command, ...(config.args || []).map(String)];
+            if (command.length === 0) {
+                throw new Error("falta el comando del servidor local");
+            }
+            const env = {};
+            for (const [key, value] of Object.entries(process.env)) {
+                if (value !== undefined) {
+                    env[key] = value;
+                }
+            }
+            Object.assign(env, config.environment || {});
+            const transport = new StdioClientTransport({
+                command: command[0],
+                args: command.slice(1),
+                env,
+                cwd: config.cwd || this.root,
+                // Su salida de errores no debe ensuciar la pantalla
+                stderr: "pipe",
+            });
+            transport.stderr?.on("data", (d) => debugLog("mcp stderr", server.name, d.toString().slice(0, 500)));
+            await withTimeout(client.connect(transport), "arrancar");
+        }
+        if (!server.client) {
+            server.client = client;
+        }
+        const listed = await withTimeout(server.client.listTools(), "listar herramientas");
+        server.tools = (listed.tools || []).map((tool) => this.wrapTool(server, tool));
+    }
+    wrapTool(server, tool) {
+        const fullName = sanitizeName(`${server.name}_${tool.name}`);
+        let parameters = cleanSchema(tool.inputSchema || { type: "object", properties: {} });
+        if (!parameters || parameters.type !== "object") {
+            parameters = { type: "object", properties: {} };
+        }
+        const description = String(tool.description || tool.title || tool.name).slice(0, 1024);
+        return {
+            name: fullName,
+            description: `${description} (herramienta MCP de ${server.name})`,
+            parameters,
+            permission: "mcp",
+            readOnly: tool.annotations?.readOnlyHint === true,
+            run: async (args, ctx) => {
+                const preview = truncate(JSON.stringify(args, null, 2), 2000);
+                const reply = await ctx.ask({ kind: "mcp", title: `Usar ${server.name} → ${tool.name}`, preview, subject: fullName });
+                if (!reply.allow) {
+                    if (reply.feedback) {
+                        return `El usuario ha rechazado usar ${fullName}. Motivo: ${reply.feedback}`;
+                    }
+                    return `El usuario ha rechazado usar ${fullName}.`;
+                }
+                if (!server.client) {
+                    return { output: `Error: el servidor MCP ${server.name} no está conectado.`, isError: true };
+                }
+                const result = await server.client.callTool({ name: tool.name, arguments: args }, undefined, {
+                    signal: ctx.signal,
+                    timeout: 300000,
+                });
+                const { output, images } = toText(result);
+                if (result.isError) {
+                    return { output: `Error: ${truncate(output)}`, isError: true, images };
+                }
+                return { output: truncate(output), images };
+            },
+        };
+    }
+    tools() {
+        const all = [];
+        for (const server of this.servers.values()) {
+            if (server.state === "conectado") {
+                all.push(...server.tools);
+            }
+        }
+        return all;
+    }
+    status() {
+        return [...this.servers.values()].map((server) => ({
+            name: server.name,
+            state: server.state,
+            error: server.error,
+            tools: server.tools.length,
+        }));
+    }
+    async close() {
+        await Promise.allSettled([...this.servers.values()].map(async (server) => {
+            if (server.client) {
+                await server.client.close();
+            }
+        }));
+    }
+}

package/dist/meta.js

@@ -0,0 +1,7 @@
+import { createRequire } from "node:module";
+// La versión sale de package.json, para que al publicar solo haya que cambiarla allí
+const require = createRequire(import.meta.url);
+export const VERSION = require("../package.json").version;
+export const REPO_URL = "https://github.com/PabloVip/vipcode";
+// Nombre del paquete en npm
+export const PACKAGE_NAME = "vipcode";

package/dist/paths.js

@@ -0,0 +1,53 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+// Carpeta de datos de vipcode (VIPCODE_HOME permite usar otra, por ejemplo en pruebas)
+export const HOME_DIR = process.env.VIPCODE_HOME || path.join(os.homedir(), ".vipcode");
+export const CONFIG_PATH = path.join(HOME_DIR, "config.json");
+export const STATE_PATH = path.join(HOME_DIR, "state.json");
+// Claves añadidas con "vipcode auth login" o /connect (solo legible por tu usuario)
+export const AUTH_PATH = path.join(HOME_DIR, "auth.json");
+// Modelos descubiertos automáticamente en cada proveedor
+export const MODELS_CACHE_PATH = path.join(HOME_DIR, "models.json");
+// Puntuaciones de LLM Stats descargadas con la API (si tienes clave)
+export const RANKING_PATH = path.join(HOME_DIR, "ranking.json");
+export const HISTORY_PATH = path.join(HOME_DIR, "history.jsonl");
+// Avisos que ya has visto (por ejemplo el de privacidad de los proveedores sin clave)
+export const NOTICES_PATH = path.join(HOME_DIR, "notices.json");
+// Última comprobación de versiones nuevas en GitHub
+export const UPDATE_PATH = path.join(HOME_DIR, "update.json");
+// Carpetas en las que confías para usar la configuración que traen
+export const TRUST_PATH = path.join(HOME_DIR, "trusted.json");
+export const SESSIONS_DIR = path.join(HOME_DIR, "sessions");
+export const SNAPSHOTS_DIR = path.join(HOME_DIR, "snapshots");
+export const EXPORTS_DIR = path.join(HOME_DIR, "exports");
+export const GLOBAL_AGENTS_DIR = path.join(HOME_DIR, "agents");
+export const GLOBAL_COMMANDS_DIR = path.join(HOME_DIR, "commands");
+// Skills instaladas con "vipcode skills add" o creadas con "vipcode skills new"
+export const GLOBAL_SKILLS_DIR = path.join(HOME_DIR, "skills");
+// Instrucciones que se aplican a todos tus proyectos
+export const GLOBAL_INSTRUCTIONS_PATH = path.join(HOME_DIR, "AGENTS.md");
+export const DEBUG_LOG_PATH = path.join(HOME_DIR, "debug.log");
+// La carpeta de datos guarda claves y conversaciones: solo la puede abrir tu usuario
+export function ensureHomeDir() {
+    fs.mkdirSync(HOME_DIR, { recursive: true, mode: 0o700 });
+    try {
+        fs.chmodSync(HOME_DIR, 0o700);
+    }
+    catch {
+        // en Windows o en carpetas que no son tuyas no se puede: no pasa nada
+    }
+}
+// Carpeta donde está instalado vipcode (la que contiene dist/)
+export const INSTALL_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+// Lo que el agente no puede tocar: los datos de vipcode (claves, configuración, carpetas de confianza) ni leerlos,
+// y su propio código no modificarlo. Quien desarrolle vipcode con vipcode puede permitir lo segundo con
+// VIPCODE_ALLOW_SELF_EDIT=1.
+export function protectedDirs() {
+    const dirs = [{ dir: HOME_DIR, read: true }];
+    if (process.env.VIPCODE_ALLOW_SELF_EDIT !== "1") {
+        dirs.push({ dir: INSTALL_DIR, read: false });
+    }
+    return dirs;
+}