vipcode 0.0.0-stage → 0.2.1

package/dist/sanitize.js

@@ -0,0 +1,38 @@
+// Lo que llega del modelo, de las herramientas o de los proveedores no puede mover el cursor, borrar la pantalla,
+// cambiar el portapapeles (OSC 52) ni disfrazar un comando en el diálogo de permiso
+// Secuencias completas (CSI, OSC, DCS…) y escapes sueltos
+const SEQUENCES = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?|\x1b[PX^_][^\x1b]*(?:\x1b\\)?|\x1b[@-Z\\-_]?/g;
+// Caracteres de control salvo el tabulador y el salto de línea (incluye \r y los C1, como el CSI de un byte)
+const CONTROLS = /[\x00-\x08\x0b-\x1f\x7f-\x9f]/g;
+// Colores y estilos (SGR): son inofensivos salvo «oculto» (8), que escondería texto
+const SGR = /\x1b\[([0-9;]*)m/g;
+// Para enseñar texto que no es nuestro
+export function stripControl(text) {
+    return String(text).replace(SEQUENCES, "").replace(CONTROLS, "");
+}
+// Para nuestros propios bloques (tablas con colores) que llevan dentro datos de fuera: deja solo los colores
+export function stripUnsafe(text) {
+    const input = String(text);
+    let result = "";
+    let last = 0;
+    for (const match of input.matchAll(SGR)) {
+        result += stripControl(input.slice(last, match.index));
+        if (!match[1].split(";").includes("8")) {
+            result += match[0];
+        }
+        last = (match.index || 0) + match[0].length;
+    }
+    return result + stripControl(input.slice(last));
+}
+// Para lo que vas a aprobar (comandos, rutas, diffs): los caracteres de control se ven en vez de actuar
+export function showControl(text) {
+    return String(text).replace(CONTROLS, (char) => {
+        if (char === "\x1b") {
+            return "␛";
+        }
+        if (char === "\r") {
+            return "␍";
+        }
+        return `\\x${char.charCodeAt(0).toString(16).padStart(2, "0")}`;
+    });
+}

package/dist/session.js

@@ -0,0 +1,219 @@
+import fs from "node:fs";
+import path from "node:path";
+import { EXPORTS_DIR, HISTORY_PATH, SESSIONS_DIR, ensureHomeDir } from "./paths.js";
+export function newSession(cwd) {
+    const now = new Date();
+    // id legible y ordenable: 20261029-174512-k3x
+    const stamp = now.toISOString().replace(/[-:T]/g, "").slice(0, 14).replace(/(\d{8})(\d{6})/, "$1-$2");
+    const suffix = Math.random().toString(36).slice(2, 5);
+    return {
+        id: `${stamp}-${suffix}`,
+        title: "(sin título)",
+        cwd,
+        created: Date.now(),
+        updated: Date.now(),
+        messages: [],
+        todos: [],
+        turns: [],
+        redo: [],
+        epoch: 0,
+        usage: { prompt: 0, completion: 0 },
+    };
+}
+// Las sesiones de la versión anterior no tenían todos los campos
+function normalize(data) {
+    return {
+        id: String(data.id),
+        title: data.title || "(sin título)",
+        cwd: data.cwd || "",
+        created: data.created || data.updated || Date.now(),
+        updated: data.updated || Date.now(),
+        messages: Array.isArray(data.messages) ? data.messages : [],
+        todos: Array.isArray(data.todos) ? data.todos : [],
+        turns: Array.isArray(data.turns) ? data.turns : [],
+        redo: Array.isArray(data.redo) ? data.redo : [],
+        epoch: data.epoch || 0,
+        usage: data.usage || { prompt: 0, completion: 0 },
+        agent: data.agent,
+    };
+}
+function firstUserText(session) {
+    const first = session.messages.find((m) => m.role === "user");
+    if (!first) {
+        return "";
+    }
+    if (typeof first.content === "string") {
+        return first.content;
+    }
+    if (Array.isArray(first.content)) {
+        const part = first.content.find((p) => p.type === "text");
+        return part?.text || "";
+    }
+    return "";
+}
+export function saveSession(session) {
+    if (session.messages.length === 0) {
+        return;
+    }
+    fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+    session.updated = Date.now();
+    if (session.title === "(sin título)") {
+        // Sin los ficheros adjuntos con @
+        const text = firstUserText(session).split("\n\nFicheros adjuntos con @")[0];
+        if (text) {
+            session.title = text.replace(/\s+/g, " ").trim().slice(0, 60);
+        }
+    }
+    fs.writeFileSync(path.join(SESSIONS_DIR, `${session.id}.json`), JSON.stringify(session));
+}
+export function listSessions(cwd) {
+    if (!fs.existsSync(SESSIONS_DIR)) {
+        return [];
+    }
+    const sessions = [];
+    for (const file of fs.readdirSync(SESSIONS_DIR)) {
+        if (!file.endsWith(".json")) {
+            continue;
+        }
+        try {
+            const data = normalize(JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, file), "utf8")));
+            if (!cwd || data.cwd === cwd) {
+                sessions.push(data);
+            }
+        }
+        catch {
+            // sesión corrupta: la ignoramos
+        }
+    }
+    sessions.sort((a, b) => b.updated - a.updated);
+    return sessions;
+}
+export function loadSession(id) {
+    try {
+        return normalize(JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, `${id}.json`), "utf8")));
+    }
+    catch {
+        return null;
+    }
+}
+export function deleteSession(id) {
+    const file = path.join(SESSIONS_DIR, `${id}.json`);
+    if (!fs.existsSync(file)) {
+        return false;
+    }
+    fs.rmSync(file);
+    return true;
+}
+function contentText(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            if (part.type === "text") {
+                return part.text;
+            }
+            if (part.type === "image_url") {
+                return "[imagen]";
+            }
+            return "";
+        })
+            .join("\n");
+    }
+    return "";
+}
+// La conversación en Markdown, para guardarla o compartirla
+export function exportMarkdown(session) {
+    const lines = [
+        `# ${session.title}`,
+        "",
+        `- Carpeta: \`${session.cwd}\``,
+        `- Empezada: ${new Date(session.created).toLocaleString()}`,
+        `- Última actividad: ${new Date(session.updated).toLocaleString()}`,
+        `- Tokens: ${session.usage.prompt} de entrada, ${session.usage.completion} de salida`,
+        "",
+    ];
+    for (const message of session.messages) {
+        if (message.role === "system") {
+            continue;
+        }
+        if (message.role === "user") {
+            let text = contentText(message.content);
+            const attached = text.indexOf("\n\nFicheros adjuntos con @");
+            if (attached >= 0) {
+                const names = [...text.slice(attached).matchAll(/<(?:fichero|carpeta) ruta="([^"]+)">/g)].map((match) => match[1]);
+                text = `${text.slice(0, attached)}\n\n_Adjuntos: ${names.join(", ")}_`;
+            }
+            lines.push("## Tú", "", text, "");
+        }
+        else if (message.role === "assistant") {
+            const text = contentText(message.content);
+            lines.push("## vipcode", "");
+            if (text.trim() !== "") {
+                lines.push(text, "");
+            }
+            const calls = message.tool_calls || [];
+            for (const call of calls) {
+                let args = call.function?.arguments || "";
+                if (args.length > 600) {
+                    args = `${args.slice(0, 600)}…`;
+                }
+                lines.push(`> 🔧 **${call.function?.name}** \`${args.replace(/`/g, "'")}\``, "");
+            }
+        }
+        else if (message.role === "tool") {
+            let text = contentText(message.content);
+            if (text.length > 2000) {
+                text = `${text.slice(0, 2000)}\n[…]`;
+            }
+            lines.push("<details><summary>Resultado</summary>", "", "```", text.replace(/```/g, "'''"), "```", "", "</details>", "");
+        }
+    }
+    return lines.join("\n");
+}
+export function saveExport(session) {
+    fs.mkdirSync(EXPORTS_DIR, { recursive: true });
+    const file = path.join(EXPORTS_DIR, `${session.id}.md`);
+    fs.writeFileSync(file, exportMarkdown(session));
+    return file;
+}
+// Historial de lo que escribes (flechas arriba/abajo), compartido entre sesiones
+export function loadHistory() {
+    try {
+        return fs
+            .readFileSync(HISTORY_PATH, "utf8")
+            .split("\n")
+            .filter((line) => line.trim() !== "")
+            .map((line) => {
+            try {
+                return String(JSON.parse(line));
+            }
+            catch {
+                return line;
+            }
+        })
+            .slice(-500);
+    }
+    catch {
+        return [];
+    }
+}
+export function appendHistory(text) {
+    if (text.trim() === "") {
+        return;
+    }
+    try {
+        ensureHomeDir();
+        fs.appendFileSync(HISTORY_PATH, `${JSON.stringify(text)}\n`);
+        // De vez en cuando lo recortamos para que no crezca sin fin
+        const stat = fs.statSync(HISTORY_PATH);
+        if (stat.size > 512 * 1024) {
+            const lines = fs.readFileSync(HISTORY_PATH, "utf8").split("\n").filter(Boolean).slice(-1000);
+            fs.writeFileSync(HISTORY_PATH, `${lines.join("\n")}\n`);
+        }
+    }
+    catch {
+        // no es grave
+    }
+}

package/dist/skills.js

@@ -0,0 +1,374 @@
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { parseFrontmatter } from "./frontmatter.js";
+import { GLOBAL_SKILLS_DIR } from "./paths.js";
+import { truncate } from "./tools.js";
+const MAX_BODY = 40000;
+const SKILL_FILES = ["SKILL.md", "skill.md", "Skill.md"];
+// Nombre según el estándar: minúsculas, números y guiones, hasta 64 caracteres
+export function normalizeSkillName(name) {
+    return name
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/[̀-ͯ]/g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 64)
+        .replace(/-+$/, "");
+}
+function tildify(file) {
+    const home = os.homedir();
+    if (file === home || file.startsWith(home + path.sep)) {
+        return `~${file.slice(home.length)}`;
+    }
+    return file;
+}
+function safeReaddir(dir) {
+    try {
+        return fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    }
+    catch {
+        return [];
+    }
+}
+function skillFile(dir) {
+    for (const name of SKILL_FILES) {
+        const file = path.join(dir, name);
+        if (fs.existsSync(file) && fs.statSync(file).isFile()) {
+            return file;
+        }
+    }
+    return null;
+}
+function readSkill(dir, where) {
+    const file = skillFile(dir);
+    if (!file) {
+        return null;
+    }
+    let text = "";
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return null;
+    }
+    const { data, body } = parseFrontmatter(text);
+    const name = normalizeSkillName(String(data.name || path.basename(dir)));
+    if (!name) {
+        return null;
+    }
+    let description = typeof data.description === "string" ? data.description.trim() : "";
+    if (!description) {
+        // Sin descripción, la primera línea con texto: el agente la necesita para saber cuándo usarla
+        description =
+            body
+                .split("\n")
+                .map((line) => line.replace(/^#+\s*/, "").trim())
+                .find((line) => line !== "") || `Skill ${name}`;
+    }
+    return {
+        name,
+        description: description.replace(/\s+/g, " ").slice(0, 1024),
+        dir,
+        body: body.trim(),
+        where,
+        userInvocable: data["user-invocable"] !== false,
+        modelInvocable: data["disable-model-invocation"] !== true,
+    };
+}
+// La carpeta puede ser una skill (en "paths" del config) o contener una skill por subcarpeta
+function scanDir(dir, where) {
+    const self = readSkill(dir, where);
+    if (self) {
+        return [self];
+    }
+    const result = [];
+    for (const entry of safeReaddir(dir)) {
+        if (entry.name.startsWith(".") || (!entry.isDirectory() && !entry.isSymbolicLink())) {
+            continue;
+        }
+        const skill = readSkill(path.join(dir, entry.name), where);
+        if (skill) {
+            result.push(skill);
+        }
+    }
+    return result;
+}
+// Dónde se buscan, de menos a más prioridad (con el mismo nombre gana la última: las del proyecto)
+export function skillDirs(root, config) {
+    const home = os.homedir();
+    const external = config.skills?.external !== false;
+    const dirs = [];
+    if (external) {
+        for (const parts of [[".claude", "skills"], [".config", "opencode", "skill"], [".config", "opencode", "skills"], [".agents", "skills"]]) {
+            dirs.push({ dir: path.join(home, ...parts), where: `~/${parts.join("/")}` });
+        }
+    }
+    dirs.push({ dir: GLOBAL_SKILLS_DIR, where: tildify(GLOBAL_SKILLS_DIR) });
+    if (external) {
+        for (const parts of [[".claude", "skills"], [".opencode", "skill"], [".opencode", "skills"], [".agents", "skills"]]) {
+            dirs.push({ dir: path.join(root, ...parts), where: parts.join("/") });
+        }
+    }
+    dirs.push({ dir: path.join(root, ".vipcode", "skills"), where: ".vipcode/skills" });
+    for (const extra of config.skills?.paths || []) {
+        dirs.push({ dir: path.resolve(root, String(extra).replace(/^~(?=$|[\\/])/, home)), where: String(extra) });
+    }
+    return dirs;
+}
+export function loadSkills(root, config) {
+    if (config.skills?.enabled === false) {
+        return [];
+    }
+    const disabled = new Set((config.skills?.disabled || []).map((name) => normalizeSkillName(String(name))));
+    const found = new Map();
+    for (const { dir, where } of skillDirs(root, config)) {
+        for (const skill of scanDir(dir, where)) {
+            if (!disabled.has(skill.name)) {
+                found.set(skill.name, skill);
+            }
+        }
+    }
+    return [...found.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+// Ficheros que trae la skill además de SKILL.md, para que el agente sepa qué puede leer
+function skillFiles(dir, max = 60) {
+    const result = [];
+    const walk = (current, prefix, depth) => {
+        for (const entry of safeReaddir(current)) {
+            if (result.length >= max || depth > 3) {
+                return;
+            }
+            if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "__pycache__") {
+                continue;
+            }
+            const relative = prefix ? `${prefix}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                walk(path.join(current, entry.name), relative, depth + 1);
+            }
+            else if (!SKILL_FILES.includes(relative)) {
+                result.push(relative);
+            }
+        }
+    };
+    walk(dir, "", 0);
+    return result;
+}
+// Lo que recibe el modelo al cargar una skill (con la herramienta o con /nombre)
+export function skillContent(skill) {
+    let extra = "";
+    const files = skillFiles(skill.dir);
+    if (files.length > 0) {
+        extra = `\n\nFicheros de la skill (en ${skill.dir}):\n${files.map((file) => `- ${file}`).join("\n")}\nLéelos con la herramienta skill (name: "${skill.name}", file: "ruta") y ejecuta sus scripts con bash usando la ruta completa.`;
+    }
+    return `<skill name="${skill.name}" dir="${skill.dir}">\n${truncate(skill.body, MAX_BODY)}\n</skill>${extra}`;
+}
+// Un fichero de la skill (sin salir de su carpeta)
+export function readSkillFile(skill, file) {
+    const abs = path.resolve(skill.dir, file);
+    let real = abs;
+    let base = skill.dir;
+    try {
+        real = fs.realpathSync(abs);
+        base = fs.realpathSync(skill.dir);
+    }
+    catch {
+        return `Error: la skill ${skill.name} no tiene el fichero ${file}.`;
+    }
+    if (real !== base && !real.startsWith(base + path.sep)) {
+        return `Error: ${file} está fuera de la carpeta de la skill.`;
+    }
+    if (fs.statSync(real).isDirectory()) {
+        const entries = safeReaddir(real).map((entry) => (entry.isDirectory() ? `${entry.name}/` : entry.name));
+        return `Contenido de ${file}:\n${entries.join("\n") || "(vacía)"}`;
+    }
+    const buffer = fs.readFileSync(real);
+    if (buffer.subarray(0, 8000).includes(0)) {
+        return `${file} es un fichero binario (${buffer.length} bytes): úsalo desde bash con la ruta ${real}.`;
+    }
+    return `<fichero skill="${skill.name}" ruta="${file}">\n${truncate(buffer.toString("utf8"), MAX_BODY)}\n</fichero>`;
+}
+// En la lista que va en cada petición, descripciones cortas: los modelos gratis tienen poco contexto
+const LISTED_DESCRIPTION = 250;
+// Herramienta para que el agente cargue una skill cuando la tarea encaja con su descripción
+export function skillTool(skills) {
+    const listed = skills.filter((skill) => skill.modelInvocable);
+    const short = (text) => (text.length > LISTED_DESCRIPTION ? `${text.slice(0, LISTED_DESCRIPTION - 1)}…` : text);
+    return {
+        name: "skill",
+        description: `Carga una skill: instrucciones y recursos para un tipo de tarea concreto. Si la tarea encaja con la descripción de alguna, cárgala antes de empezar y sigue sus instrucciones. Con "file" lees uno de sus ficheros (por ejemplo references/guia.md).\nSkills disponibles:\n${listed
+            .map((skill) => `- ${skill.name}: ${short(skill.description)}`)
+            .join("\n")}`,
+        parameters: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Nombre de la skill" },
+                file: { type: "string", description: "Opcional: fichero de la skill que quieres leer, relativo a su carpeta" },
+            },
+            required: ["name"],
+        },
+        permission: "none",
+        readOnly: true,
+        async run(args) {
+            const wanted = normalizeSkillName(String(args.name || ""));
+            const skill = skills.find((item) => item.name === wanted);
+            if (!skill) {
+                return `Error: no hay ninguna skill llamada «${args.name}». Disponibles: ${listed.map((item) => item.name).join(", ") || "ninguna"}.`;
+            }
+            if (args.file) {
+                return readSkillFile(skill, String(args.file));
+            }
+            return skillContent(skill);
+        },
+    };
+}
+// Las carpetas de vipcode donde se instalan (las de Claude Code u opencode no se tocan)
+export function installDir(root, project) {
+    if (project) {
+        return path.join(root, ".vipcode", "skills");
+    }
+    return GLOBAL_SKILLS_DIR;
+}
+// Carpetas con SKILL.md dentro de un directorio (ella misma o hasta 4 niveles más abajo)
+function findSkillFolders(dir, depth = 0) {
+    if (skillFile(dir)) {
+        return [dir];
+    }
+    if (depth >= 4) {
+        return [];
+    }
+    const result = [];
+    for (const entry of safeReaddir(dir)) {
+        if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+            result.push(...findSkillFolders(path.join(dir, entry.name), depth + 1));
+        }
+    }
+    return result;
+}
+// github.com/usuario/repo, …/tree/rama/carpeta, usuario/repo o cualquier URL de git
+function parseGitSource(source) {
+    const github = /^https?:\/\/github\.com\/([^/\s]+)\/([^/\s]+?)(?:\.git)?(?:\/(?:tree|blob)\/([^/\s]+)(?:\/(.+?))?)?\/?$/.exec(source);
+    if (github) {
+        let subdir = github[4];
+        // Un enlace a …/SKILL.md apunta a su carpeta
+        if (subdir && /(^|\/)skill\.md$/i.test(subdir)) {
+            subdir = path.posix.dirname(subdir);
+        }
+        return { url: `https://github.com/${github[1]}/${github[2]}.git`, ref: github[3], subdir };
+    }
+    if (/^[\w.-]+\/[\w.-]+$/.test(source)) {
+        return { url: `https://github.com/${source}.git` };
+    }
+    if (/^(https?:\/\/|git@|ssh:\/\/|file:\/\/).+/.test(source) || source.endsWith(".git")) {
+        return { url: source };
+    }
+    return null;
+}
+// Copia las skills de una carpeta o de un repositorio git a la carpeta de vipcode
+export function installSkills(source, root, options = {}) {
+    const result = { installed: [], skipped: [] };
+    let base = path.resolve(root, source.replace(/^~(?=$|[\\/])/, os.homedir()));
+    let temp = null;
+    try {
+        if (!fs.existsSync(base)) {
+            const git = parseGitSource(source);
+            if (!git) {
+                throw new Error(`No encuentro ${source}: pon la ruta de una carpeta con SKILL.md o la dirección de un repositorio git.`);
+            }
+            temp = fs.mkdtempSync(path.join(os.tmpdir(), "vipcode-skill-"));
+            // Con «--» un origen que empiece por - no se toma como una opción de git (por ejemplo --upload-pack)
+            const args = ["clone", "--depth", "1", ...(git.ref ? [`--branch=${git.ref}`] : []), "--", git.url, temp];
+            const clone = spawnSync("git", args, { encoding: "utf8", timeout: 120000, env: { ...process.env, GIT_TERMINAL_PROMPT: "0" } });
+            if (clone.error || clone.status !== 0) {
+                throw new Error(`No he podido descargar ${git.url}: ${(clone.stderr || clone.error?.message || "").trim().split("\n").pop()}`);
+            }
+            base = git.subdir ? path.join(temp, git.subdir) : temp;
+            if (!fs.existsSync(base)) {
+                throw new Error(`El repositorio no tiene la carpeta ${git.subdir}.`);
+            }
+        }
+        const folders = findSkillFolders(base);
+        if (folders.length === 0) {
+            throw new Error(`No hay ninguna skill (carpeta con SKILL.md) en ${source}.`);
+        }
+        const target = installDir(root, Boolean(options.project));
+        fs.mkdirSync(target, { recursive: true });
+        for (const folder of folders) {
+            const skill = readSkill(folder, "");
+            if (!skill) {
+                continue;
+            }
+            const dest = path.join(target, skill.name);
+            if (fs.existsSync(dest)) {
+                if (!options.force) {
+                    result.skipped.push({ name: skill.name, reason: "ya existe (usa --force para sustituirla)" });
+                    continue;
+                }
+                fs.rmSync(dest, { recursive: true, force: true });
+            }
+            fs.cpSync(folder, dest, { recursive: true, filter: (file) => path.basename(file) !== ".git" });
+            result.installed.push({ name: skill.name, dir: dest });
+        }
+    }
+    finally {
+        if (temp) {
+            fs.rmSync(temp, { recursive: true, force: true });
+        }
+    }
+    return result;
+}
+// Crea una skill nueva con una plantilla para rellenar
+export function createSkill(name, root, project) {
+    const clean = normalizeSkillName(name);
+    if (!clean) {
+        throw new Error("El nombre solo puede tener letras, números y guiones.");
+    }
+    const dir = path.join(installDir(root, project), clean);
+    if (fs.existsSync(dir)) {
+        throw new Error(`Ya existe ${tildify(dir)}.`);
+    }
+    fs.mkdirSync(dir, { recursive: true });
+    const title = clean.replace(/-/g, " ").replace(/^./, (letter) => letter.toUpperCase());
+    fs.writeFileSync(path.join(dir, "SKILL.md"), `---
+name: ${clean}
+description: Explica en una o dos frases qué hace esta skill y cuándo usarla (por ejemplo «Úsala cuando el usuario pida…»). Con esta frase decide el agente si la carga.
+---
+
+# ${title}
+
+## Cuándo usarla
+
+- …
+
+## Instrucciones
+
+1. …
+2. …
+
+## Ejemplos
+
+- …
+
+<!-- Puedes añadir scripts/ y references/ en esta carpeta y nombrarlos aquí: el agente los lee cuando los necesita. -->
+`);
+    return dir;
+}
+// Borra una skill de las carpetas de vipcode (las de otros programas no se tocan)
+export function removeSkill(name, root, config) {
+    const clean = normalizeSkillName(name);
+    const own = [path.join(root, ".vipcode", "skills"), GLOBAL_SKILLS_DIR];
+    for (const dir of own) {
+        const skill = scanDir(dir, "").find((item) => item.name === clean);
+        if (skill) {
+            fs.rmSync(skill.dir, { recursive: true, force: true });
+            return skill.dir;
+        }
+    }
+    const elsewhere = loadSkills(root, config).find((item) => item.name === clean);
+    if (elsewhere) {
+        throw new Error(`La skill ${clean} está en ${elsewhere.where}, que no es de vipcode: bórrala desde allí o añádela a "skills.disabled" en la configuración.`);
+    }
+    throw new Error(`No hay ninguna skill llamada ${clean}.`);
+}