alegra-data-agent 0.1.0

package/dist/lib.js

@@ -0,0 +1,221 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, relative, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+export const PRODUCT_NAME = "alegra-data-agent";
+export const COMMAND_NAME = "alegra-data-agent";
+export const REPO_SLUG = "alegradev/alegra-data-agent";
+export const REPO_DEFAULT_BRANCH = "main";
+export const GATEWAY_URL = process.env.ALEGRA_DATA_AGENT_GATEWAY_URL ??
+    "https://alegra-data-agent.vercel.app";
+export const ALL_TARGETS = ["claude-code", "cursor", "opencode", "antigravity"];
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export function getPackageRoot() {
+    return join(__dirname, "..");
+}
+export function getRegistryDir() {
+    return join(getPackageRoot(), "skills-registry");
+}
+export function getManifestPath() {
+    return join(getRegistryDir(), "index.json");
+}
+export function getClaudeSkillsDir() {
+    return join(homedir(), ".claude", "skills");
+}
+export function getClaudeSettingsPath() {
+    return join(homedir(), ".claude", "settings.json");
+}
+export function getCursorSkillsDir() {
+    return join(homedir(), ".cursor", "rules");
+}
+export function getCursorMcpPath() {
+    return join(homedir(), ".cursor", "mcp.json");
+}
+export function getOpenCodeSkillsDir() {
+    const xdgHome = process.env.XDG_CONFIG_HOME;
+    const base = xdgHome && xdgHome.length > 0 ? xdgHome : join(homedir(), ".config");
+    return join(base, "opencode", "prompts");
+}
+export function getOpenCodeConfigPath() {
+    const xdgHome = process.env.XDG_CONFIG_HOME;
+    const base = xdgHome && xdgHome.length > 0 ? xdgHome : join(homedir(), ".config");
+    return join(base, "opencode", "opencode.json");
+}
+export function getAntigravitySkillsDir() {
+    return join(homedir(), ".antigravity", "skills");
+}
+export function getAntigravitySettingsPath() {
+    return join(homedir(), ".antigravity", "settings.json");
+}
+export function getTargetSkillsDir(target) {
+    switch (target) {
+        case "claude-code":
+            return getClaudeSkillsDir();
+        case "cursor":
+            return getCursorSkillsDir();
+        case "opencode":
+            return getOpenCodeSkillsDir();
+        case "antigravity":
+            return getAntigravitySkillsDir();
+    }
+}
+export function getTargetMcpConfigPath(target) {
+    switch (target) {
+        case "claude-code":
+            return getClaudeSettingsPath();
+        case "cursor":
+            return getCursorMcpPath();
+        case "opencode":
+            return getOpenCodeConfigPath();
+        case "antigravity":
+            return getAntigravitySettingsPath();
+    }
+}
+export function getLockFilePath() {
+    return join(getConfigDir(), "lock.json");
+}
+export function getConfigDir() {
+    const xdgHome = process.env.XDG_CONFIG_HOME;
+    const base = xdgHome && xdgHome.length > 0 ? xdgHome : join(homedir(), ".config");
+    return join(base, PRODUCT_NAME);
+}
+export function getAuthFilePath() {
+    return join(getConfigDir(), "auth.json");
+}
+let _cachedVersion = null;
+export function getPackageVersion() {
+    if (_cachedVersion)
+        return _cachedVersion;
+    try {
+        const pkg = JSON.parse(readFileSync(join(getPackageRoot(), "package.json"), "utf-8"));
+        _cachedVersion = pkg.version ?? "0.0.0";
+    }
+    catch {
+        _cachedVersion = "0.0.0";
+    }
+    return _cachedVersion;
+}
+export function readManifest() {
+    const path = getManifestPath();
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function readLockFile() {
+    const path = getLockFilePath();
+    if (!existsSync(path)) {
+        return { schemaVersion: 1, productName: PRODUCT_NAME, skills: {} };
+    }
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return { schemaVersion: 1, productName: PRODUCT_NAME, skills: {} };
+    }
+}
+export function writeLockFile(lock) {
+    const path = getLockFilePath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(lock, null, 2) + "\n", "utf-8");
+}
+export function sha256(buf) {
+    return createHash("sha256").update(buf).digest("hex");
+}
+export function sha256File(path) {
+    return sha256(readFileSync(path));
+}
+export function computeBundleHash(files) {
+    const lines = Object.keys(files)
+        .sort()
+        .map((k) => `${k}:${files[k]}`)
+        .join("\n");
+    return sha256(lines);
+}
+export function walkSkillFiles(skillDir) {
+    const out = [];
+    const walk = (dir) => {
+        for (const entry of readdirSync(dir)) {
+            const full = join(dir, entry);
+            const st = statSync(full);
+            if (st.isDirectory()) {
+                walk(full);
+            }
+            else if (st.isFile()) {
+                const rel = relative(skillDir, full).split(sep).join("/");
+                out.push(rel);
+            }
+        }
+    };
+    walk(skillDir);
+    return out.sort();
+}
+export function parseFrontmatter(markdown) {
+    const match = markdown.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return {};
+    const result = {};
+    const lines = match[1].split(/\r?\n/);
+    let state = { kind: "top" };
+    const finalizeBlock = (s) => {
+        const joined = s.mode === "folded" ? s.lines.join(" ").replace(/\s+/g, " ").trim() : s.lines.join("\n");
+        result[s.key] = joined;
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (state.kind === "block") {
+            if (/^\s+/.test(line) || line === "") {
+                state.lines.push(line.replace(/^ {2}/, ""));
+                continue;
+            }
+            finalizeBlock(state);
+            state = { kind: "top" };
+        }
+        if (state.kind === "map") {
+            if (/^\s+/.test(line)) {
+                const sub = line.trim().match(/^([a-zA-Z_-]+):\s*(.*)$/);
+                if (sub) {
+                    const [, k, v] = sub;
+                    result[k] = v.replace(/^["']|["']$/g, "");
+                }
+                continue;
+            }
+            state = { kind: "top" };
+        }
+        const kv = line.match(/^([a-zA-Z_-]+):\s*(.*)$/);
+        if (!kv)
+            continue;
+        const [, k, v] = kv;
+        if (v === ">" || v === ">-" || v === ">+") {
+            state = { kind: "block", key: k, mode: "folded", lines: [] };
+        }
+        else if (v === "|" || v === "|-" || v === "|+") {
+            state = { kind: "block", key: k, mode: "literal", lines: [] };
+        }
+        else if (v === "") {
+            state = { kind: "map", key: k };
+        }
+        else {
+            result[k] = v.replace(/^["']|["']$/g, "");
+        }
+    }
+    if (state.kind === "block")
+        finalizeBlock(state);
+    return result;
+}
+export function formatBytes(n) {
+    if (n < 1024)
+        return `${n} B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)} KB`;
+    return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+export function ensureDir(path) {
+    if (!existsSync(path))
+        mkdirSync(path, { recursive: true });
+}

package/dist/main.js

@@ -0,0 +1,162 @@
+import { ALL_TARGETS, getPackageVersion } from "./lib.js";
+import { helpText } from "./ui.js";
+import { log, logError } from "./colors.js";
+import { runCheck } from "./commands/check.js";
+import { runHookInstall, runHookUninstall } from "./commands/hook.js";
+import { runInstall } from "./commands/install.js";
+import { runList } from "./commands/list.js";
+import { runLogin } from "./commands/login.js";
+import { runLogout } from "./commands/logout.js";
+import { runStatus } from "./commands/status.js";
+import { runUninstall } from "./commands/uninstall.js";
+import { runUpdate } from "./commands/update.js";
+import { runWhoami } from "./commands/whoami.js";
+function parseTargetList(raw) {
+    const out = [];
+    for (const piece of raw.split(",").map((s) => s.trim()).filter(Boolean)) {
+        if (ALL_TARGETS.includes(piece)) {
+            out.push(piece);
+        }
+        else {
+            throw new Error(`Target desconocido: '${piece}'. Válidos: ${ALL_TARGETS.join(", ")}`);
+        }
+    }
+    return out;
+}
+function parseArgs(argv) {
+    const flags = {
+        yes: false,
+        dryRun: false,
+        force: false,
+        help: false,
+        version: false,
+        noHook: false,
+        autoUpdate: false,
+    };
+    const positional = [];
+    const only = [];
+    const targets = [];
+    let i = 0;
+    while (i < argv.length) {
+        const a = argv[i];
+        if (a === "-y" || a === "--yes")
+            flags.yes = true;
+        else if (a === "--dry-run")
+            flags.dryRun = true;
+        else if (a === "--force")
+            flags.force = true;
+        else if (a === "--no-hook")
+            flags.noHook = true;
+        else if (a === "--auto-update")
+            flags.autoUpdate = true;
+        else if (a === "-h" || a === "--help")
+            flags.help = true;
+        else if (a === "-v" || a === "--version")
+            flags.version = true;
+        else if (a === "--only") {
+            i++;
+            if (argv[i])
+                only.push(...argv[i].split(","));
+        }
+        else if (a.startsWith("--only=")) {
+            only.push(...a.slice("--only=".length).split(","));
+        }
+        else if (a === "--target") {
+            i++;
+            if (argv[i])
+                targets.push(...parseTargetList(argv[i]));
+        }
+        else if (a.startsWith("--target=")) {
+            targets.push(...parseTargetList(a.slice("--target=".length)));
+        }
+        else {
+            positional.push(a);
+        }
+        i++;
+    }
+    return {
+        command: positional[0] ?? "install",
+        subcommand: positional[1],
+        flags,
+        only,
+        targets,
+    };
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.flags.version) {
+        log(getPackageVersion());
+        process.exit(0);
+    }
+    if (args.flags.help || args.command === "help") {
+        log(helpText());
+        process.exit(0);
+    }
+    let exitCode = 0;
+    switch (args.command) {
+        case "login":
+            exitCode = await runLogin({ force: args.flags.force });
+            break;
+        case "logout":
+            exitCode = runLogout();
+            break;
+        case "whoami":
+            exitCode = runWhoami();
+            break;
+        case "install":
+            exitCode = await runInstall({
+                yes: args.flags.yes,
+                dryRun: args.flags.dryRun,
+                force: args.flags.force,
+                only: args.only.length > 0 ? args.only : undefined,
+                targets: args.targets.length > 0 ? args.targets : undefined,
+                noHook: args.flags.noHook,
+                hookMode: args.flags.autoUpdate ? "auto" : "check",
+            });
+            break;
+        case "update":
+            exitCode = await runUpdate({
+                yes: args.flags.yes,
+                dryRun: args.flags.dryRun,
+                targets: args.targets.length > 0 ? args.targets : undefined,
+            });
+            break;
+        case "list":
+        case "ls":
+            exitCode = await runList();
+            break;
+        case "status":
+            exitCode = await runStatus();
+            break;
+        case "check":
+            exitCode = await runCheck();
+            break;
+        case "uninstall":
+            exitCode = await runUninstall({ yes: args.flags.yes, dryRun: args.flags.dryRun });
+            break;
+        case "hook":
+            if (args.subcommand === "install") {
+                exitCode = runHookInstall(args.flags.autoUpdate ? "auto" : "check");
+            }
+            else if (args.subcommand === "uninstall") {
+                exitCode = runHookUninstall();
+            }
+            else {
+                logError(`Subcomando desconocido: 'hook ${args.subcommand ?? ""}'. Usa: hook install [--auto-update] | hook uninstall`);
+                exitCode = 1;
+            }
+            break;
+        case "version":
+            log(getPackageVersion());
+            break;
+        default:
+            logError(`Comando desconocido: '${args.command}'.`);
+            log(helpText());
+            exitCode = 1;
+    }
+    process.exit(exitCode);
+}
+main().catch((err) => {
+    logError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/dist/render.js

@@ -0,0 +1,68 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseFrontmatter } from "./lib.js";
+function readSkillEntryPoint(skillDir) {
+    const candidates = ["SKILL.md", "README.md"];
+    for (const c of candidates) {
+        const p = join(skillDir, c);
+        if (existsSync(p)) {
+            return { content: readFileSync(p, "utf-8"), path: p };
+        }
+    }
+    throw new Error(`No SKILL.md ni README.md en ${skillDir}`);
+}
+export function renderSkillForTarget(skillSrcDir, skillName, format) {
+    if (format === "folder") {
+        return { kind: "folder" };
+    }
+    const { content } = readSkillEntryPoint(skillSrcDir);
+    const fm = parseFrontmatter(content);
+    const body = stripFrontmatter(content);
+    if (format === "cursor-mdc") {
+        const desc = fm.description ?? `Skill ${skillName}`;
+        const cursorDesc = desc.startsWith("USE WHEN") ? desc : `USE WHEN ${desc}`;
+        const safeDesc = cursorDesc.replace(/\n/g, " ").replace(/"/g, '\\"');
+        const mdc = `---\ndescription: "${safeDesc}"\nalwaysApply: false\n---\n\n${body}`;
+        return { kind: "single", filename: `${skillName}.mdc`, content: mdc };
+    }
+    if (format === "flat-md") {
+        return { kind: "single", filename: `${skillName}.md`, content: body };
+    }
+    const _exhaustive = format;
+    throw new Error(`SkillFormat no soportado: ${String(_exhaustive)}`);
+}
+function stripFrontmatter(content) {
+    const m = content.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n([\s\S]*)$/);
+    if (!m)
+        return content;
+    return m[1].replace(/^\s+/, "");
+}
+export function renderMcpForTarget(mcp, spec) {
+    const obj = {
+        [spec.mcpUrlKey]: mcp.url,
+    };
+    if (spec.opencodeShape) {
+        obj.type = "remote";
+        obj.enabled = true;
+    }
+    if (mcp.auth.type === "gateway") {
+        if (!mcp.auth.tokenEnv) {
+            throw new Error(`MCP '${mcp.name}' es type=gateway pero no trae tokenEnv`);
+        }
+        obj.headers = {
+            Authorization: bearerInterpolation(mcp.auth.tokenEnv, spec.id),
+        };
+    }
+    return obj;
+}
+function bearerInterpolation(env, target) {
+    switch (target) {
+        case "claude-code":
+        case "antigravity":
+            return `Bearer \${${env}}`;
+        case "cursor":
+            return `Bearer \${env:${env}}`;
+        case "opencode":
+            return `Bearer {env:${env}}`;
+    }
+}

package/dist/signature.js

@@ -0,0 +1,61 @@
+import { createPublicKey, verify } from "node:crypto";
+export const SIGNING_KEY_ID = "alegra-data-agent-v1";
+export const PUBLIC_KEY_B64 = "MCowBQYDK2VwAyEApoojQPy6INQXl/xZ0gQumsI3tt9HvMrb0PaVlNn7TkE=";
+export function canonicalize(obj) {
+    if (obj === null || typeof obj !== "object")
+        return JSON.stringify(obj);
+    if (Array.isArray(obj)) {
+        return "[" + obj.map((v) => canonicalize(v)).join(",") + "]";
+    }
+    const o = obj;
+    const keys = Object.keys(o).filter((k) => k !== "signature").sort();
+    return "{" + keys.map((k) => JSON.stringify(k) + ":" + canonicalize(o[k])).join(",") + "}";
+}
+const MAX_MANIFEST_AGE_DAYS = 90;
+export function verifyManifestSignature(manifest, options = {}) {
+    const sig = manifest.signature;
+    if (!sig) {
+        if (options.softFail) {
+            return { ok: true, warning: "manifest no firmado (modo transición)" };
+        }
+        return { ok: false, reason: "manifest no incluye signature" };
+    }
+    if (sig.alg !== "Ed25519") {
+        return { ok: false, reason: `algoritmo no soportado: ${sig.alg}` };
+    }
+    if (sig.keyId !== SIGNING_KEY_ID) {
+        return { ok: false, reason: `keyId no reconocido: ${sig.keyId} (CLI espera ${SIGNING_KEY_ID})` };
+    }
+    if (typeof manifest.generatedAt === "string") {
+        const ts = Date.parse(manifest.generatedAt);
+        if (!isNaN(ts)) {
+            const ageMs = Date.now() - ts;
+            const maxAgeMs = MAX_MANIFEST_AGE_DAYS * 24 * 3600 * 1000;
+            if (ageMs > maxAgeMs) {
+                return {
+                    ok: false,
+                    reason: `manifest demasiado viejo (${Math.round(ageMs / (24 * 3600 * 1000))}d, máx ${MAX_MANIFEST_AGE_DAYS}d)`,
+                };
+            }
+            if (ageMs < -3600_000) {
+                return { ok: false, reason: "manifest tiene generatedAt en el futuro" };
+            }
+        }
+    }
+    const canonical = canonicalize(manifest);
+    const publicKey = createPublicKey({
+        key: Buffer.from(PUBLIC_KEY_B64, "base64"),
+        format: "der",
+        type: "spki",
+    });
+    if (publicKey.asymmetricKeyType !== "ed25519") {
+        return {
+            ok: false,
+            reason: `tipo de clave pública no es Ed25519 (got: ${publicKey.asymmetricKeyType})`,
+        };
+    }
+    const ok = verify(null, Buffer.from(canonical, "utf-8"), publicKey, Buffer.from(sig.value, "base64"));
+    if (!ok)
+        return { ok: false, reason: "firma criptográficamente inválida" };
+    return { ok: true };
+}

package/dist/targets.js

@@ -0,0 +1,61 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getAntigravitySettingsPath, getAntigravitySkillsDir, getClaudeSettingsPath, getClaudeSkillsDir, getCursorMcpPath, getCursorSkillsDir, getOpenCodeConfigPath, getOpenCodeSkillsDir, } from "./lib.js";
+export const TARGETS = {
+    "claude-code": {
+        id: "claude-code",
+        label: "Claude Code",
+        skillsDir: getClaudeSkillsDir(),
+        skillFormat: "folder",
+        mcpConfigPath: getClaudeSettingsPath(),
+        mcpRootKey: "mcpServers",
+        mcpUrlKey: "url",
+    },
+    cursor: {
+        id: "cursor",
+        label: "Cursor",
+        skillsDir: getCursorSkillsDir(),
+        skillFormat: "cursor-mdc",
+        mcpConfigPath: getCursorMcpPath(),
+        mcpRootKey: "mcpServers",
+        mcpUrlKey: "url",
+    },
+    opencode: {
+        id: "opencode",
+        label: "OpenCode",
+        skillsDir: getOpenCodeSkillsDir(),
+        skillFormat: "flat-md",
+        mcpConfigPath: getOpenCodeConfigPath(),
+        mcpRootKey: "mcp",
+        mcpUrlKey: "url",
+        opencodeShape: true,
+    },
+    antigravity: {
+        id: "antigravity",
+        label: "Antigravity",
+        skillsDir: getAntigravitySkillsDir(),
+        skillFormat: "folder",
+        mcpConfigPath: getAntigravitySettingsPath(),
+        mcpRootKey: "mcpServers",
+        mcpUrlKey: "serverUrl",
+    },
+};
+export function detectInstalledTargets() {
+    const home = homedir();
+    const xdgConfig = process.env.XDG_CONFIG_HOME && process.env.XDG_CONFIG_HOME.length > 0
+        ? process.env.XDG_CONFIG_HOME
+        : join(home, ".config");
+    const sentinels = {
+        "claude-code": join(home, ".claude"),
+        cursor: join(home, ".cursor"),
+        opencode: join(xdgConfig, "opencode"),
+        antigravity: join(home, ".antigravity"),
+    };
+    const out = [];
+    for (const id of Object.keys(sentinels)) {
+        if (existsSync(sentinels[id]))
+            out.push(id);
+    }
+    return out;
+}

package/dist/ui.js

@@ -0,0 +1,71 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { bold, cyan, dim, gray, log } from "./colors.js";
+import { COMMAND_NAME, getPackageVersion } from "./lib.js";
+export function banner() {
+    const v = getPackageVersion();
+    log("");
+    log(bold(cyan(`  ${COMMAND_NAME}`)) + dim(`  v${v}`));
+    log(gray("  Agente de Data — equipo BI Data · Alegra"));
+    log("");
+}
+export async function confirm(question, defaultYes = true) {
+    const suffix = defaultYes ? "[Y/n]" : "[y/N]";
+    const rl = createInterface({ input, output });
+    try {
+        const answer = (await rl.question(`${question} ${dim(suffix)} `)).trim().toLowerCase();
+        if (answer === "")
+            return defaultYes;
+        return answer === "y" || answer === "yes" || answer === "si" || answer === "sí";
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function ask(question, defaultValue) {
+    const rl = createInterface({ input, output });
+    try {
+        const suffix = defaultValue ? dim(`(${defaultValue})`) + " " : "";
+        const answer = (await rl.question(`${question} ${suffix}`)).trim();
+        return answer === "" && defaultValue !== undefined ? defaultValue : answer;
+    }
+    finally {
+        rl.close();
+    }
+}
+export function helpText() {
+    return `
+${bold(COMMAND_NAME)} — Agente de Data interno de Alegra
+
+${bold("Uso:")}
+  pnpm dlx ${COMMAND_NAME} <comando> [opciones]
+
+${bold("Comandos:")}
+  login              Autenticarte con tu cuenta @alegra.com
+  logout             Cerrar sesión (borra el token local)
+  whoami             Mostrar la cuenta actualmente autenticada
+  install            Instala skills + MCPs en tus clientes (Claude Code, Cursor, OpenCode, Antigravity)
+  update             Re-descarga skills/MCPs que cambiaron
+  list               Lista skills y MCPs disponibles en el gateway
+  status             Muestra estado: auth, instalado, drift
+  check              Compara local vs gateway (usado por el hook SessionStart)
+  hook install       Habilita aviso automático de actualizaciones al abrir el cliente
+  hook uninstall     Deshabilita el aviso automático
+  uninstall          Elimina las skills/MCPs instaladas por este paquete
+  help               Muestra esta ayuda
+  version            Muestra la versión
+
+${bold("Opciones:")}
+  -y, --yes            No pedir confirmación
+      --dry-run        Mostrar qué se haría, sin tocar archivos
+      --only=a,b,c     Instalar solo esas skills/MCPs
+      --target=NAME    Restringir al cliente NAME (claude-code|cursor|opencode|antigravity)
+      --no-hook        No instalar el hook de SessionStart
+      --auto-update    Hook en modo auto-update (instala en silencio)
+  -h, --help           Mostrar ayuda
+  -v, --version        Mostrar versión
+
+${bold("Documentación:")}
+  https://github.com/alegradev/alegra-data-agent
+`;
+}