@cocaxcode/ai-context-inspector 0.3.3 → 0.4.0

package/dist/{chunk-CAQUPN6F.js → chunk-3NLUFQSB.js}

@@ -3030,9 +3030,948 @@ function escHtml(str) {
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 
+// src/ecosystem/types.ts
+var ACI_DIR = ".aci";
+var ACI_BUNDLE = "bundle.json";
+var ACI_README = "README.md";
+
+// src/ecosystem/secrets.ts
+var SENSITIVE_VAR_REGEX = /key|token|secret|password|credential|auth/i;
+var VAR_REFERENCE_REGEX = /^\$\{.+\}$/;
+var ARG_VAR_REGEX = /\$\{([^}]+)\}/g;
+function isSensitiveVar(varName) {
+  return SENSITIVE_VAR_REGEX.test(varName);
+}
+function detectEnvVars(servers) {
+  const vars = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const server of servers) {
+    if (server.config.env) {
+      for (const [varName, value] of Object.entries(server.config.env)) {
+        const key = `${server.name}:${varName}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        vars.push({
+          serverName: server.name,
+          varName,
+          value,
+          isSensitive: isSensitiveVar(varName)
+        });
+      }
+    }
+    if (server.config.args) {
+      for (const arg of server.config.args) {
+        let match;
+        while ((match = ARG_VAR_REGEX.exec(arg)) !== null) {
+          const varName = match[1];
+          const key = `${server.name}:${varName}`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          vars.push({
+            serverName: server.name,
+            varName,
+            value: `\${${varName}}`,
+            isSensitive: isSensitiveVar(varName)
+          });
+        }
+      }
+    }
+  }
+  return vars;
+}
+function redactValue(varName) {
+  return `\${${varName}}`;
+}
+function applySecretsPolicy(env, mode, customDecisions) {
+  if (!env || Object.keys(env).length === 0) {
+    return { env: void 0, redacted: [], included: [] };
+  }
+  const processed = {};
+  const redacted = [];
+  const included = [];
+  for (const [varName, value] of Object.entries(env)) {
+    if (VAR_REFERENCE_REGEX.test(value)) {
+      processed[varName] = value;
+      included.push(varName);
+      continue;
+    }
+    if (mode === "none") {
+      processed[varName] = redactValue(varName);
+      redacted.push(varName);
+    } else if (mode === "all") {
+      processed[varName] = value;
+      included.push(varName);
+    } else {
+      const include = customDecisions?.[varName] ?? false;
+      if (include) {
+        processed[varName] = value;
+        included.push(varName);
+      } else {
+        processed[varName] = redactValue(varName);
+        redacted.push(varName);
+      }
+    }
+  }
+  return { env: processed, redacted, included };
+}
+
+// src/ecosystem/export.ts
+import { readFile as readFile7, writeFile, readdir as readdir5, stat as stat5, mkdir } from "fs/promises";
+import { join as join7, basename as basename3, dirname, relative as relative2 } from "path";
+import { createHash } from "crypto";
+async function exportEcosystem(options) {
+  const scan = await runAllScanners({
+    dir: options.dir,
+    includeUser: options.includeUser,
+    introspect: false,
+    timeout: 5e3
+  });
+  const resources = await buildBundleResources(scan, options);
+  const checksum = computeChecksum(resources);
+  const warnings = [];
+  if (options.secrets === "all") {
+    warnings.push("Secretos incluidos sin redactar. No compartas este bundle publicamente.");
+  }
+  for (const w of scan.warnings) {
+    warnings.push(`[${w.scanner}] ${w.message}`);
+  }
+  const bundle = {
+    version: 1,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sourceProject: scan.project.name,
+    checksum,
+    warnings,
+    resources
+  };
+  const aciDir = join7(options.dir, ACI_DIR);
+  await writeBundle(bundle, aciDir);
+  const readme = generateReadme(bundle);
+  await writeFile(join7(aciDir, ACI_README), readme, "utf-8");
+  await ensureGitignore(options.dir);
+  return bundle;
+}
+async function buildBundleResources(scan, options) {
+  const categories = options.only ?? ["mcp", "skills", "agents", "memories", "context"];
+  const projectDir = scan.project.path;
+  const resources = {
+    mcpServers: [],
+    skills: [],
+    agents: [],
+    memories: [],
+    contextFiles: []
+  };
+  if (categories.includes("mcp")) {
+    resources.mcpServers = buildMcpServers(scan, options);
+  }
+  if (categories.includes("skills")) {
+    resources.skills = await buildSkills(scan);
+  }
+  if (categories.includes("agents")) {
+    resources.agents = await buildAgents(scan);
+  }
+  if (categories.includes("memories")) {
+    resources.memories = await buildMemories(scan, projectDir);
+  }
+  if (categories.includes("context")) {
+    resources.contextFiles = await buildContextFiles(scan);
+  }
+  return resources;
+}
+function buildMcpServers(scan, options) {
+  const servers = [];
+  for (const server of scan.mcpServers) {
+    const { env, redacted, included } = applySecretsPolicy(
+      server.config.env,
+      options.secrets,
+      options.secretDecisions
+    );
+    const scope = server.source === "user" || server.source === "desktop" ? "user" : "project";
+    servers.push({
+      name: server.name,
+      scope,
+      config: {
+        transport: server.config.transport,
+        command: server.config.command,
+        args: server.config.args,
+        env,
+        url: server.config.url
+      },
+      envVarsRedacted: redacted,
+      envVarsIncluded: included
+    });
+  }
+  return servers;
+}
+async function buildSkills(scan) {
+  const skills = [];
+  for (const skill of scan.skills) {
+    try {
+      const content = await readFile7(skill.path, "utf-8");
+      const dirName = basename3(dirname(skill.path));
+      skills.push({
+        name: skill.name,
+        scope: skill.scope,
+        dirName,
+        content,
+        description: skill.description,
+        triggers: skill.triggers
+      });
+    } catch {
+    }
+  }
+  return skills;
+}
+async function buildAgents(scan) {
+  const agents = [];
+  for (const agent of scan.agents) {
+    try {
+      const content = await readFile7(agent.path, "utf-8");
+      const fileName = basename3(agent.path);
+      agents.push({
+        name: agent.name,
+        scope: agent.scope,
+        fileName,
+        content,
+        description: agent.description,
+        model: agent.model
+      });
+    } catch {
+    }
+  }
+  return agents;
+}
+async function buildMemories(scan, projectDir) {
+  const memories = [];
+  for (const memory of scan.memories) {
+    if (memory.source !== "filesystem") continue;
+    if (!memory.path) continue;
+    const files = [];
+    try {
+      if (memory.type === "atl" || memory.type === "openspec") {
+        const cleanPath = memory.path.endsWith("/") ? memory.path.slice(0, -1) : memory.path;
+        const absDir = join7(projectDir, cleanPath);
+        const dirFiles = await readDirRecursive(absDir, absDir);
+        files.push(...dirFiles);
+      } else if (memory.type === "claude-memory") {
+        const content = await readFile7(memory.path, "utf-8");
+        files.push({ relativePath: basename3(memory.path), content });
+      } else if (memory.type === "agent-memory") {
+        const s = await stat5(memory.path);
+        if (s.isDirectory()) {
+          const entries = await readdir5(memory.path);
+          for (const entry of entries) {
+            if (!entry.endsWith(".md")) continue;
+            const filePath = join7(memory.path, entry);
+            const content = await readFile7(filePath, "utf-8");
+            files.push({ relativePath: entry, content });
+          }
+        } else {
+          const content = await readFile7(memory.path, "utf-8");
+          files.push({ relativePath: basename3(memory.path), content });
+        }
+      }
+    } catch {
+    }
+    const scope = memory.type === "claude-memory" || memory.type === "agent-memory" ? "user" : "project";
+    if (files.length > 0) {
+      memories.push({ type: memory.type, scope, files });
+    }
+  }
+  return memories;
+}
+async function buildContextFiles(scan) {
+  const contextFiles = [];
+  for (const cf of scan.contextFiles) {
+    if (cf.type === "directory" && cf.children) {
+      for (const child of cf.children) {
+        if (child.type === "file") {
+          try {
+            const content = await readFile7(child.absolutePath, "utf-8");
+            contextFiles.push({
+              path: child.path,
+              scope: child.scope,
+              tool: child.tool,
+              content
+            });
+          } catch {
+          }
+        }
+      }
+    } else if (cf.type === "file") {
+      try {
+        const content = await readFile7(cf.absolutePath, "utf-8");
+        contextFiles.push({
+          path: cf.path,
+          scope: cf.scope,
+          tool: cf.tool,
+          content
+        });
+      } catch {
+      }
+    }
+  }
+  return contextFiles;
+}
+async function readDirRecursive(dirPath, basePath) {
+  const files = [];
+  try {
+    const entries = await readdir5(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join7(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        const subFiles = await readDirRecursive(fullPath, basePath);
+        files.push(...subFiles);
+      } else if (entry.isFile()) {
+        try {
+          const content = await readFile7(fullPath, "utf-8");
+          files.push({
+            relativePath: relative2(basePath, fullPath),
+            content
+          });
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function computeChecksum(resources) {
+  const json = JSON.stringify(resources, Object.keys(resources).sort());
+  return createHash("sha256").update(json).digest("hex");
+}
+function verifyChecksum(bundle) {
+  const computed = computeChecksum(bundle.resources);
+  return computed === bundle.checksum;
+}
+async function writeBundle(bundle, dir) {
+  await mkdir(dir, { recursive: true });
+  const filePath = join7(dir, ACI_BUNDLE);
+  const json = JSON.stringify(bundle, null, 2);
+  await writeFile(filePath, json, "utf-8");
+  return filePath;
+}
+function generateReadme(bundle) {
+  const r = bundle.resources;
+  const lines = [
+    "# ACI Export Bundle",
+    "",
+    `Proyecto: **${bundle.sourceProject}**`,
+    `Fecha: ${bundle.createdAt}`,
+    `Version: ${bundle.version}`,
+    "",
+    "## Contenido",
+    "",
+    `| Categoria | Cantidad |`,
+    `|-----------|----------|`,
+    `| MCP Servers | ${r.mcpServers.length} |`,
+    `| Skills | ${r.skills.length} |`,
+    `| Agents | ${r.agents.length} |`,
+    `| Memories | ${r.memories.length} |`,
+    `| Context Files | ${r.contextFiles.length} |`,
+    ""
+  ];
+  if (r.mcpServers.length > 0) {
+    lines.push("## MCP Servers", "");
+    for (const s of r.mcpServers) {
+      lines.push(`- **${s.name}** (${s.config.transport}, ${s.scope})`);
+      if (s.envVarsRedacted.length > 0) {
+        lines.push(`  - Redactadas: ${s.envVarsRedacted.join(", ")}`);
+      }
+    }
+    lines.push("");
+  }
+  if (r.skills.length > 0) {
+    lines.push("## Skills", "");
+    for (const s of r.skills) {
+      lines.push(`- **${s.name}** \u2014 ${s.description ?? "sin descripcion"}`);
+    }
+    lines.push("");
+  }
+  if (r.agents.length > 0) {
+    lines.push("## Agents", "");
+    for (const a of r.agents) {
+      lines.push(`- **${a.name}** \u2014 ${a.description ?? "sin descripcion"}`);
+    }
+    lines.push("");
+  }
+  if (r.contextFiles.length > 0) {
+    lines.push("## Context Files", "");
+    for (const cf of r.contextFiles) {
+      lines.push(`- \`${cf.path}\` (${cf.tool})`);
+    }
+    lines.push("");
+  }
+  if (bundle.warnings.length > 0) {
+    lines.push("## Advertencias", "");
+    for (const w of bundle.warnings) {
+      lines.push(`- ${w}`);
+    }
+    lines.push("");
+  }
+  lines.push("---", "Generado por [@cocaxcode/ai-context-inspector](https://github.com/cocaxcode/ai-context-inspector)", "");
+  return lines.join("\n");
+}
+async function ensureGitignore(dir) {
+  const gitignorePath = join7(dir, ".gitignore");
+  const entry = ".aci/";
+  let content = "";
+  try {
+    content = await readFile7(gitignorePath, "utf-8");
+  } catch {
+  }
+  const lines = content.split("\n");
+  if (lines.some((line) => line.trim() === entry)) {
+    return false;
+  }
+  const newContent = content.length > 0 && !content.endsWith("\n") ? content + "\n" + entry + "\n" : content + entry + "\n";
+  await writeFile(gitignorePath, newContent, "utf-8");
+  return true;
+}
+
+// src/ecosystem/detect-target.ts
+import { access } from "fs/promises";
+import { join as join8 } from "path";
+
+// src/ecosystem/target-map.ts
+var TARGET_CONFIGS = {
+  claude: {
+    mcpConfigPath: ".mcp.json",
+    mcpConfigFormat: "flat",
+    contextFilePath: "CLAUDE.md",
+    rulesDir: null,
+    skillsDir: ".claude/skills",
+    agentsDir: ".claude/agents"
+  },
+  cursor: {
+    mcpConfigPath: ".cursor/mcp.json",
+    mcpConfigFormat: "flat",
+    contextFilePath: ".cursorrules",
+    rulesDir: ".cursor/rules",
+    skillsDir: null,
+    agentsDir: null
+  },
+  windsurf: {
+    mcpConfigPath: ".mcp.json",
+    mcpConfigFormat: "flat",
+    contextFilePath: ".windsurfrules",
+    rulesDir: ".windsurf/rules",
+    skillsDir: null,
+    agentsDir: null
+  },
+  copilot: {
+    mcpConfigPath: ".vscode/mcp.json",
+    mcpConfigFormat: "flat",
+    contextFilePath: ".github/copilot-instructions.md",
+    rulesDir: ".github/instructions",
+    skillsDir: null,
+    agentsDir: ".github/agents"
+  },
+  gemini: {
+    mcpConfigPath: ".gemini/settings.json",
+    mcpConfigFormat: "nested",
+    contextFilePath: "GEMINI.md",
+    rulesDir: ".gemini/rules",
+    skillsDir: null,
+    agentsDir: null
+  },
+  codex: {
+    mcpConfigPath: ".mcp.json",
+    mcpConfigFormat: "flat",
+    contextFilePath: "AGENTS.md",
+    rulesDir: ".codex/rules",
+    skillsDir: null,
+    agentsDir: null
+  },
+  opencode: {
+    mcpConfigPath: "opencode.json",
+    mcpConfigFormat: "nested",
+    contextFilePath: "OPENCODE.md",
+    rulesDir: ".opencode/rules",
+    skillsDir: null,
+    agentsDir: null
+  }
+};
+var TOOL_MARKERS = {
+  claude: ["CLAUDE.md", ".claude", ".mcp.json"],
+  cursor: [".cursorrules", ".cursor"],
+  windsurf: [".windsurfrules", ".windsurf"],
+  copilot: [
+    ".github/copilot-instructions.md",
+    ".github/agents",
+    ".vscode/mcp.json"
+  ],
+  gemini: ["GEMINI.md", ".gemini"],
+  codex: ["AGENTS.md", ".codex"],
+  opencode: ["OPENCODE.md", ".opencode", "opencode.json"]
+};
+var PRIMARY_CONTEXT_MAP = {
+  "CLAUDE.md": "claude",
+  ".cursorrules": "cursor",
+  ".windsurfrules": "windsurf",
+  ".github/copilot-instructions.md": "copilot",
+  "GEMINI.md": "gemini",
+  "AGENTS.md": "codex",
+  "OPENCODE.md": "opencode"
+};
+
+// src/ecosystem/detect-target.ts
+async function detectTargetTools(dir) {
+  const results = [];
+  for (const [target, markers] of Object.entries(TOOL_MARKERS)) {
+    let count = 0;
+    for (const marker of markers) {
+      try {
+        await access(join8(dir, marker));
+        count++;
+      } catch {
+      }
+    }
+    if (count > 0) {
+      results.push({ target, count });
+    }
+  }
+  results.sort((a, b) => b.count - a.count);
+  return results.map((r) => r.target);
+}
+
+// src/ecosystem/import.ts
+import { readFile as readFile8, writeFile as writeFile2, mkdir as mkdir2, access as access2 } from "fs/promises";
+import { join as join9, dirname as dirname2 } from "path";
+import { homedir as homedir6 } from "os";
+async function loadBundle(filePath, dir) {
+  const resolvedPath = filePath ?? join9(dir ?? ".", ACI_DIR, ACI_BUNDLE);
+  let raw;
+  try {
+    raw = await readFile8(resolvedPath, "utf-8");
+  } catch {
+    throw new Error(`Bundle no encontrado: ${resolvedPath}`);
+  }
+  let bundle;
+  try {
+    bundle = JSON.parse(raw);
+  } catch {
+    throw new Error(`Bundle no es JSON valido: ${resolvedPath}`);
+  }
+  if (bundle.version !== 1) {
+    throw new Error(`Version no soportada: ${bundle.version}. Se requiere version 1.`);
+  }
+  if (!verifyChecksum(bundle)) {
+    throw new Error("Checksum invalido: el bundle puede estar corrupto o modificado.");
+  }
+  return bundle;
+}
+async function planImport(bundle, options) {
+  let target;
+  if (options.target) {
+    target = options.target;
+  } else {
+    const detected = await detectTargetTools(options.dir);
+    if (detected.length === 0) {
+      throw new Error("No se detecto ninguna herramienta AI. Usa --target para especificar una.");
+    }
+    target = detected[0];
+  }
+  const config = TARGET_CONFIGS[target];
+  const categories = options.only ?? ["mcp", "skills", "agents", "memories", "context"];
+  const actions = [];
+  const pendingEnvVars = [];
+  if (categories.includes("mcp")) {
+    for (const server of bundle.resources.mcpServers) {
+      const scope = resolveScope(server.scope, options.scope);
+      const basePath = getScopedBasePath(options.dir, scope);
+      const mcpPath = join9(basePath, config.mcpConfigPath);
+      const conflict = await checkMcpConflict(
+        server.name,
+        server.config,
+        mcpPath,
+        config.mcpConfigFormat
+      );
+      let action;
+      let reason;
+      if (conflict === "missing") {
+        action = "install";
+      } else if (conflict === "same") {
+        action = "skip";
+        reason = "Misma configuracion ya existe";
+      } else {
+        if (options.force) {
+          action = "overwrite";
+          reason = "Configuracion diferente (--force)";
+        } else {
+          action = "skip";
+          reason = "Configuracion diferente (usa --force para sobreescribir)";
+        }
+      }
+      actions.push({
+        category: "mcp",
+        name: server.name,
+        action,
+        reason,
+        targetPath: mcpPath
+      });
+      for (const varName of server.envVarsRedacted) {
+        if (!pendingEnvVars.includes(varName)) {
+          pendingEnvVars.push(varName);
+        }
+      }
+    }
+  }
+  if (categories.includes("skills")) {
+    for (const skill of bundle.resources.skills) {
+      const scope = resolveScope(skill.scope, options.scope);
+      const basePath = getScopedBasePath(options.dir, scope);
+      if (config.skillsDir) {
+        const skillPath = join9(basePath, config.skillsDir, skill.dirName, "SKILL.md");
+        const exists = await fileExists(skillPath);
+        if (exists && !options.force) {
+          actions.push({
+            category: "skills",
+            name: skill.name,
+            action: "skip",
+            reason: "Skill ya existe (usa --force para sobreescribir)",
+            targetPath: skillPath
+          });
+        } else {
+          actions.push({
+            category: "skills",
+            name: skill.name,
+            action: exists ? "overwrite" : "install",
+            reason: exists ? "Sobreescribiendo skill existente (--force)" : void 0,
+            targetPath: skillPath
+          });
+        }
+      } else if (config.rulesDir) {
+        const rulePath = join9(basePath, config.rulesDir, `${skill.dirName}.md`);
+        const exists = await fileExists(rulePath);
+        if (exists && !options.force) {
+          actions.push({
+            category: "skills",
+            name: skill.name,
+            action: "skip",
+            reason: "Regla ya existe (usa --force para sobreescribir)",
+            targetPath: rulePath
+          });
+        } else {
+          actions.push({
+            category: "skills",
+            name: skill.name,
+            action: exists ? "overwrite" : "install",
+            reason: exists ? "Sobreescribiendo como regla (--force)" : "Instalando como regla",
+            targetPath: rulePath
+          });
+        }
+      } else {
+        actions.push({
+          category: "skills",
+          name: skill.name,
+          action: "unsupported",
+          reason: `${target} no soporta skills ni rules`,
+          targetPath: ""
+        });
+      }
+    }
+  }
+  if (categories.includes("agents")) {
+    for (const agent of bundle.resources.agents) {
+      const scope = resolveScope(agent.scope, options.scope);
+      const basePath = getScopedBasePath(options.dir, scope);
+      if (config.agentsDir) {
+        const agentPath = join9(basePath, config.agentsDir, agent.fileName);
+        const exists = await fileExists(agentPath);
+        if (exists && !options.force) {
+          actions.push({
+            category: "agents",
+            name: agent.name,
+            action: "skip",
+            reason: "Agent ya existe (usa --force para sobreescribir)",
+            targetPath: agentPath
+          });
+        } else {
+          actions.push({
+            category: "agents",
+            name: agent.name,
+            action: exists ? "overwrite" : "install",
+            reason: exists ? "Sobreescribiendo agent existente (--force)" : void 0,
+            targetPath: agentPath
+          });
+        }
+      } else {
+        actions.push({
+          category: "agents",
+          name: agent.name,
+          action: "unsupported",
+          reason: `${target} no soporta agents`,
+          targetPath: ""
+        });
+      }
+    }
+  }
+  if (categories.includes("context")) {
+    for (const cf of bundle.resources.contextFiles) {
+      const mappedPath = mapContextFilePath(cf.path, target);
+      if (mappedPath) {
+        const scope = resolveScope(cf.scope, options.scope);
+        const basePath = getScopedBasePath(options.dir, scope);
+        const fullPath = join9(basePath, mappedPath);
+        const exists = await fileExists(fullPath);
+        if (exists && !options.force) {
+          actions.push({
+            category: "context",
+            name: cf.path,
+            action: "skip",
+            reason: "Archivo de contexto ya existe (usa --force para sobreescribir)",
+            targetPath: fullPath
+          });
+        } else {
+          actions.push({
+            category: "context",
+            name: cf.path,
+            action: exists ? "overwrite" : "install",
+            reason: exists ? "Sobreescribiendo contexto (--force)" : void 0,
+            targetPath: fullPath
+          });
+        }
+      } else {
+        actions.push({
+          category: "context",
+          name: cf.path,
+          action: "unsupported",
+          reason: `Sin equivalente en ${target}`,
+          targetPath: ""
+        });
+      }
+    }
+  }
+  if (categories.includes("memories")) {
+    for (const memory of bundle.resources.memories) {
+      const scope = resolveScope(memory.scope, options.scope);
+      const basePath = getScopedBasePath(options.dir, scope);
+      for (const file of memory.files) {
+        const filePath = join9(basePath, file.relativePath);
+        const exists = await fileExists(filePath);
+        actions.push({
+          category: "memories",
+          name: `${memory.type}/${file.relativePath}`,
+          action: exists && !options.force ? "skip" : exists ? "overwrite" : "install",
+          reason: exists && !options.force ? "Archivo de memoria ya existe" : exists ? "Sobreescribiendo memoria (--force)" : void 0,
+          targetPath: filePath
+        });
+      }
+    }
+  }
+  const summary = {
+    install: actions.filter((a) => a.action === "install").length,
+    skip: actions.filter((a) => a.action === "skip").length,
+    overwrite: actions.filter((a) => a.action === "overwrite").length,
+    unsupported: actions.filter((a) => a.action === "unsupported").length
+  };
+  return { target, actions, pendingEnvVars, summary };
+}
+async function executeImport(plan, bundle, options) {
+  const config = TARGET_CONFIGS[plan.target];
+  const installed = [];
+  const skipped = [];
+  const unsupported = [];
+  for (const action of plan.actions) {
+    if (action.action === "unsupported") {
+      unsupported.push(action);
+      continue;
+    }
+    if (action.action === "skip") {
+      skipped.push(action);
+      continue;
+    }
+    try {
+      switch (action.category) {
+        case "mcp": {
+          const server = bundle.resources.mcpServers.find((s) => s.name === action.name);
+          if (server) {
+            await installMcpServer(server, action.targetPath, config.mcpConfigFormat, options.secretValues);
+          }
+          break;
+        }
+        case "skills": {
+          const skill = bundle.resources.skills.find((s) => s.name === action.name);
+          if (skill) {
+            await installSkill(skill, options.dir, config, options.scope, options.force);
+          }
+          break;
+        }
+        case "agents": {
+          const agent = bundle.resources.agents.find((a) => a.name === action.name);
+          if (agent) {
+            await installAgent(agent, options.dir, config, options.scope, options.force);
+          }
+          break;
+        }
+        case "context": {
+          const cf = bundle.resources.contextFiles.find((c) => c.path === action.name);
+          if (cf) {
+            const mappedPath = mapContextFilePath(cf.path, plan.target);
+            if (mappedPath) {
+              await installContextFile(cf, options.dir, mappedPath);
+            }
+          }
+          break;
+        }
+        case "memories": {
+          const [memType, ...pathParts] = action.name.split("/");
+          const relPath = pathParts.join("/");
+          const memory = bundle.resources.memories.find((m) => m.type === memType);
+          if (memory) {
+            const file = memory.files.find((f) => f.relativePath === relPath);
+            if (file) {
+              await installMemory({ ...memory, files: [file] }, options.dir);
+            }
+          }
+          break;
+        }
+      }
+      installed.push(action);
+    } catch {
+      skipped.push({ ...action, reason: "Error al instalar" });
+    }
+  }
+  await ensureGitignore(options.dir);
+  return {
+    installed,
+    skipped,
+    unsupported,
+    pendingEnvVars: plan.pendingEnvVars
+  };
+}
+async function checkMcpConflict(serverName, serverConfig, mcpConfigPath, format) {
+  let raw;
+  try {
+    raw = await readFile8(mcpConfigPath, "utf-8");
+  } catch {
+    return "missing";
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return "missing";
+  }
+  const servers = format === "flat" ? parsed.mcpServers : parsed.mcpServers;
+  if (!servers || !(serverName in servers)) {
+    return "missing";
+  }
+  const existing = servers[serverName];
+  const keysToCompare = ["command", "args", "url", "transport"];
+  for (const key of keysToCompare) {
+    const a = serverConfig[key];
+    const b = existing[key];
+    if (JSON.stringify(a) !== JSON.stringify(b)) {
+      return "different";
+    }
+  }
+  return "same";
+}
+async function installMcpServer(server, mcpConfigPath, format, secretValues) {
+  let parsed = {};
+  try {
+    const raw = await readFile8(mcpConfigPath, "utf-8");
+    parsed = JSON.parse(raw);
+  } catch {
+  }
+  if (!parsed.mcpServers || typeof parsed.mcpServers !== "object") {
+    parsed.mcpServers = {};
+  }
+  const entry = {};
+  if (server.config.command) entry.command = server.config.command;
+  if (server.config.args) entry.args = server.config.args;
+  if (server.config.url) entry.url = server.config.url;
+  if (server.config.transport && server.config.transport !== "stdio") {
+    entry.transport = server.config.transport;
+  }
+  if (server.config.env) {
+    const env = { ...server.config.env };
+    if (secretValues) {
+      for (const [varName, value] of Object.entries(secretValues)) {
+        if (varName in env && value !== null) {
+          env[varName] = value;
+        }
+      }
+    }
+    entry.env = env;
+  }
+  ;
+  parsed.mcpServers[server.name] = entry;
+  await mkdir2(dirname2(mcpConfigPath), { recursive: true });
+  await writeFile2(mcpConfigPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+}
+async function installSkill(skill, dir, targetConfig, scope, force) {
+  const effectiveScope = resolveScope(skill.scope, scope);
+  const basePath = getScopedBasePath(dir, effectiveScope);
+  if (targetConfig.skillsDir) {
+    const skillDir = join9(basePath, targetConfig.skillsDir, skill.dirName);
+    const skillPath = join9(skillDir, "SKILL.md");
+    await mkdir2(skillDir, { recursive: true });
+    await writeFile2(skillPath, skill.content, "utf-8");
+  } else if (targetConfig.rulesDir) {
+    const rulesDir = join9(basePath, targetConfig.rulesDir);
+    const rulePath = join9(rulesDir, `${skill.dirName}.md`);
+    await mkdir2(rulesDir, { recursive: true });
+    await writeFile2(rulePath, skill.content, "utf-8");
+  }
+}
+async function installAgent(agent, dir, targetConfig, scope, force) {
+  if (!targetConfig.agentsDir) return;
+  const effectiveScope = resolveScope(agent.scope, scope);
+  const basePath = getScopedBasePath(dir, effectiveScope);
+  const agentsDir = join9(basePath, targetConfig.agentsDir);
+  const agentPath = join9(agentsDir, agent.fileName);
+  await mkdir2(agentsDir, { recursive: true });
+  await writeFile2(agentPath, agent.content, "utf-8");
+}
+async function installContextFile(file, dir, targetPath) {
+  const fullPath = join9(dir, targetPath);
+  await mkdir2(dirname2(fullPath), { recursive: true });
+  await writeFile2(fullPath, file.content, "utf-8");
+}
+async function installMemory(memory, dir) {
+  for (const file of memory.files) {
+    const filePath = join9(dir, file.relativePath);
+    await mkdir2(dirname2(filePath), { recursive: true });
+    await writeFile2(filePath, file.content, "utf-8");
+  }
+}
+function resolveScope(originalScope, overrideScope) {
+  if (overrideScope) return overrideScope;
+  return originalScope;
+}
+function mapContextFilePath(sourcePath, target) {
+  if (sourcePath in PRIMARY_CONTEXT_MAP) {
+    return TARGET_CONFIGS[target].contextFilePath;
+  }
+  return null;
+}
+function getScopedBasePath(dir, scope) {
+  return scope === "project" ? dir : homedir6();
+}
+async function fileExists(path) {
+  try {
+    await access2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 export {
   scanMcpConfigs,
   introspectServers,
   runAllScanners,
-  generateHtml
+  generateHtml,
+  ACI_DIR,
+  ACI_BUNDLE,
+  isSensitiveVar,
+  detectEnvVars,
+  exportEcosystem,
+  detectTargetTools,
+  loadBundle,
+  planImport,
+  executeImport
 };