@cocaxcode/ai-context-inspector 0.3.2 → 0.4.0

package/dist/index.js

@@ -1,13 +1,356 @@
 #!/usr/bin/env node
 import {
+  ACI_BUNDLE,
+  ACI_DIR,
+  detectEnvVars,
+  detectTargetTools,
+  executeImport,
+  exportEcosystem,
   generateHtml,
+  isSensitiveVar,
+  loadBundle,
+  planImport,
   runAllScanners
-} from "./chunk-G57UDS2C.js";
+} from "./chunk-3NLUFQSB.js";
 
 // src/cli.ts
 import { parseArgs } from "util";
 import { access, mkdir, writeFile } from "fs/promises";
-import { dirname, resolve } from "path";
+import { dirname, join, resolve } from "path";
+
+// src/ecosystem/prompts.ts
+import * as readline from "readline/promises";
+import { stdin, stdout } from "process";
+var CATEGORY_LABELS = {
+  mcp: "MCP Servers",
+  skills: "Skills",
+  agents: "Agents",
+  memories: "Memorias",
+  context: "Context Files"
+};
+var ALL_TARGETS = [
+  "claude",
+  "cursor",
+  "windsurf",
+  "copilot",
+  "gemini",
+  "codex",
+  "opencode"
+];
+function createPromptInterface() {
+  return readline.createInterface({ input: stdin, output: stdout });
+}
+function maskValue(value) {
+  if (value.length <= 10) return "****";
+  return `${value.slice(0, 6)}...${value.slice(-4)}`;
+}
+function parseYesNo(input) {
+  const trimmed = input.trim().toLowerCase();
+  if (["s", "si", "s\xED", "y", "yes"].includes(trimmed)) return true;
+  if (["n", "no"].includes(trimmed)) return false;
+  if (trimmed === "") return void 0;
+  return void 0;
+}
+async function askNumber(rl, prompt, min, max) {
+  while (true) {
+    const answer = await rl.question(prompt);
+    const num = parseInt(answer.trim(), 10);
+    if (!isNaN(num) && num >= min && num <= max) return num;
+    console.error(`  Entrada inv\xE1lida. Ingresa un n\xFAmero entre ${min} y ${max}.`);
+  }
+}
+function parseNumberList(input, min, max) {
+  const trimmed = input.trim();
+  if (trimmed === "") return [];
+  const parts = trimmed.split(",").map((s) => s.trim());
+  const nums = [];
+  for (const part of parts) {
+    const num = parseInt(part, 10);
+    if (isNaN(num) || num < min || num > max) return null;
+    nums.push(num);
+  }
+  return nums;
+}
+async function promptCategories(rl, available, verb) {
+  console.error(`
+Categor\xEDas disponibles para ${verb}:`);
+  for (let i = 0; i < available.length; i++) {
+    const { category, count } = available[i];
+    console.error(`  [${i + 1}] ${CATEGORY_LABELS[category]} (${count})`);
+  }
+  while (true) {
+    const answer = await rl.question(
+      "\nIngresa n\xFAmeros separados por coma, o Enter para todos: "
+    );
+    const nums = parseNumberList(answer, 1, available.length);
+    if (nums === null) {
+      console.error("  Entrada inv\xE1lida. Usa n\xFAmeros separados por coma.");
+      continue;
+    }
+    if (nums.length === 0) {
+      return available.map((a) => a.category);
+    }
+    return nums.map((n) => available[n - 1].category);
+  }
+}
+async function promptExportSecrets(rl, detectedVars) {
+  if (detectedVars.length === 0) {
+    return { mode: "none" };
+  }
+  const serverNames = new Set(detectedVars.map((v) => v.serverName));
+  console.error(
+    `
+Se detectaron ${detectedVars.length} variables de entorno en ${serverNames.size} MCP server${serverNames.size > 1 ? "s" : ""}:
+`
+  );
+  const maxVarLen = Math.max(...detectedVars.map((v) => v.varName.length));
+  const maxServerLen = Math.max(...detectedVars.map((v) => v.serverName.length));
+  for (const v of detectedVars) {
+    const varPad = v.varName.padEnd(maxVarLen);
+    const serverPad = v.serverName.padEnd(maxServerLen);
+    const label = v.isSensitive ? "\u{1F510} sensible" : "   no sensible";
+    console.error(`  ${varPad}  (${serverPad})  ${label}`);
+  }
+  console.error("\n\xBFC\xF3mo manejar los secretos?");
+  console.error("  [1] Redactar todos (reemplazar con ${VAR_NAME})");
+  console.error(
+    "  [2] Incluir todos (\u26A0\uFE0F valores reales en texto plano)"
+  );
+  console.error("  [3] Decidir uno por uno");
+  const option = await askNumber(rl, "\nOpci\xF3n: ", 1, 3);
+  if (option === 1) return { mode: "none" };
+  if (option === 2) return { mode: "all" };
+  const decisions = await promptSecretDecisionsOneByOne(rl, detectedVars);
+  return { mode: "custom", decisions };
+}
+async function promptSecretDecisionsOneByOne(rl, detectedVars) {
+  console.error("\nDecide por cada variable (S=incluir, N=redactar):\n");
+  const decisions = {};
+  for (const v of detectedVars) {
+    const defaultInclude = !v.isSensitive;
+    const defaultLabel = defaultInclude ? "S" : "N";
+    const sensitiveTag = v.isSensitive ? " \u{1F510}" : "";
+    while (true) {
+      const answer = await rl.question(
+        `  ${v.varName} (${v.serverName})${sensitiveTag} [${defaultLabel}]: `
+      );
+      const trimmed = answer.trim();
+      if (trimmed === "") {
+        decisions[v.varName] = defaultInclude;
+        break;
+      }
+      const parsed = parseYesNo(trimmed);
+      if (parsed !== void 0) {
+        decisions[v.varName] = parsed;
+        break;
+      }
+      console.error("    Entrada inv\xE1lida. Usa S (incluir) o N (redactar).");
+    }
+  }
+  return decisions;
+}
+async function promptTargetTool(rl, detected) {
+  if (detected.length === 1) {
+    return detected[0];
+  }
+  if (detected.length > 1) {
+    console.error("\nSe detectaron m\xFAltiples herramientas AI:");
+    for (let i = 0; i < detected.length; i++) {
+      console.error(`  [${i + 1}] ${detected[i]}`);
+    }
+    const option2 = await askNumber(
+      rl,
+      "\xBFCu\xE1l usar como destino? ",
+      1,
+      detected.length
+    );
+    return detected[option2 - 1];
+  }
+  console.error("\nNo se detect\xF3 ninguna herramienta AI configurada.");
+  console.error("\xBFCu\xE1l configurar?");
+  for (let i = 0; i < ALL_TARGETS.length; i++) {
+    console.error(`  [${i + 1}] ${ALL_TARGETS[i]}`);
+  }
+  const option = await askNumber(rl, "Opci\xF3n: ", 1, ALL_TARGETS.length);
+  return ALL_TARGETS[option - 1];
+}
+async function promptImportSecrets(rl, bundle) {
+  const hasReal = bundle.envVarsIncluded.length > 0;
+  const hasRedacted = bundle.envVarsRedacted.length > 0;
+  if (!hasReal && !hasRedacted) {
+    return { mode: "none" };
+  }
+  if (hasReal) {
+    console.error(
+      `
+El bundle contiene valores reales para ${bundle.envVarsIncluded.length} variable${bundle.envVarsIncluded.length > 1 ? "s" : ""}:`
+    );
+    console.error(`  ${bundle.envVarsIncluded.join(", ")}`);
+    if (hasRedacted) {
+      console.error(
+        `Y ${bundle.envVarsRedacted.length} variable${bundle.envVarsRedacted.length > 1 ? "s" : ""} redactada${bundle.envVarsRedacted.length > 1 ? "s" : ""}:`
+      );
+      console.error(`  ${bundle.envVarsRedacted.join(", ")}`);
+    }
+    console.error("\n\xBFC\xF3mo manejar los secretos?");
+    console.error("  [1] Redactar todos (dejar como ${VAR_NAME})");
+    console.error("  [2] Usar valores del bundle");
+    console.error("  [3] Decidir uno por uno");
+    const option2 = await askNumber(rl, "\nOpci\xF3n: ", 1, 3);
+    if (option2 === 1) return { mode: "none" };
+    if (option2 === 2) {
+      const values3 = {};
+      for (const v of bundle.envVarsIncluded) {
+        values3[v] = bundle.envValues[v] ?? null;
+      }
+      for (const v of bundle.envVarsRedacted) {
+        values3[v] = null;
+      }
+      return { mode: "all", values: values3 };
+    }
+    const values2 = {};
+    for (const varName of bundle.envVarsIncluded) {
+      const val = bundle.envValues[varName] ?? "";
+      const sensitive = isSensitiveVar(varName);
+      const displayVal = sensitive ? maskValue(val) : val;
+      const sensitiveTag = sensitive ? " \u{1F510}" : "";
+      console.error(`
+  ${varName} = "${displayVal}"${sensitiveTag}`);
+      console.error("    [1] Usar valor del bundle");
+      console.error(`    [2] No importar (dejar \${${varName}})`);
+      console.error("    [3] Introducir nuevo valor");
+      const opt = await askNumber(rl, "  Opci\xF3n [1]: ", 1, 3);
+      if (opt === 1) {
+        values2[varName] = val;
+      } else if (opt === 2) {
+        values2[varName] = null;
+      } else {
+        const newVal = await rl.question(`  ${varName}: `);
+        values2[varName] = newVal;
+      }
+    }
+    for (const varName of bundle.envVarsRedacted) {
+      const newVal = await rl.question(`  ${varName}: `);
+      values2[varName] = newVal.trim() === "" ? null : newVal;
+    }
+    return { mode: "custom", values: values2 };
+  }
+  console.error(
+    `
+El bundle contiene ${bundle.envVarsRedacted.length} variable${bundle.envVarsRedacted.length > 1 ? "s" : ""} redactada${bundle.envVarsRedacted.length > 1 ? "s" : ""}:`
+  );
+  console.error(`  ${bundle.envVarsRedacted.join(", ")}`);
+  console.error("\n  [1] Dejar como ${VAR_NAME} (configurar despu\xE9s)");
+  console.error("  [2] Introducir valores ahora");
+  const option = await askNumber(rl, "\nOpci\xF3n: ", 1, 2);
+  if (option === 1) return { mode: "none" };
+  const values = {};
+  console.error("");
+  for (const varName of bundle.envVarsRedacted) {
+    const newVal = await rl.question(`  ${varName}: `);
+    values[varName] = newVal.trim() === "" ? null : newVal;
+  }
+  return { mode: "custom", values };
+}
+async function promptConfirmPlan(rl, plan) {
+  console.error(`
+Plan de importaci\xF3n (${plan.target}):
+`);
+  for (const action of plan.actions) {
+    const categoryLabel = CATEGORY_LABELS[action.category] ?? action.category;
+    const shortCat = action.category === "mcp" ? "MCP" : action.category === "context" ? "Context" : categoryLabel.replace(/s$/, "");
+    if (action.action === "install") {
+      console.error(
+        `  \u2705 Instalar    ${shortCat}: ${action.name} \u2192 ${action.targetPath}`
+      );
+    } else if (action.action === "skip") {
+      const reason = action.reason ? ` (${action.reason})` : "";
+      console.error(
+        `  \u23ED\uFE0F  Omitir     ${shortCat}: ${action.name}${reason}`
+      );
+    } else if (action.action === "overwrite") {
+      console.error(
+        `  \u26A0\uFE0F  Sobrescribir ${shortCat}: ${action.name} \u2192 ${action.targetPath}`
+      );
+    } else if (action.action === "unsupported") {
+      const reason = action.reason ? ` (${action.reason})` : "";
+      console.error(
+        `  \u274C No soportado  ${shortCat}: ${action.name}${reason}`
+      );
+    }
+  }
+  console.error(
+    `
+  Resumen: ${plan.summary.install} instalar, ${plan.summary.skip} omitir, ${plan.summary.unsupported} no soportado`
+  );
+  if (plan.pendingEnvVars.length > 0) {
+    console.error(
+      `  \u26A0\uFE0F ${plan.pendingEnvVars.length} env vars pendientes: ${plan.pendingEnvVars.join(", ")}`
+    );
+  }
+  while (true) {
+    const answer = await rl.question("\n\xBFEjecutar? [s/N]: ");
+    const trimmed = answer.trim();
+    if (trimmed === "") return false;
+    const parsed = parseYesNo(trimmed);
+    if (parsed !== void 0) return parsed;
+    console.error("  Entrada inv\xE1lida. Usa s (s\xED) o n (no).");
+  }
+}
+function printImportResult(result) {
+  console.error("\nImportaci\xF3n completada:");
+  console.error(`  \u2705 ${result.installed.length} instalados`);
+  console.error(`  \u23ED\uFE0F  ${result.skipped.length} omitidos`);
+  console.error(`  \u274C ${result.unsupported.length} no soportados`);
+  if (result.pendingEnvVars.length > 0) {
+    console.error("\n  Variables de entorno pendientes de configuraci\xF3n:");
+    for (const varName of result.pendingEnvVars) {
+      console.error(`    ${varName} \u2192 configurar manualmente`);
+    }
+  }
+}
+function printExportResult(bundle, redactedVars, includedVars, gitignoreAdded) {
+  const res = bundle.resources;
+  console.error("\nBundle exportado: .aci/bundle.json");
+  if (res.mcpServers?.length > 0)
+    console.error(`  MCP Servers: ${res.mcpServers.length}`);
+  if (res.skills?.length > 0)
+    console.error(`  Skills: ${res.skills.length}`);
+  if (res.agents?.length > 0)
+    console.error(`  Agents: ${res.agents.length}`);
+  if (res.memories?.length > 0)
+    console.error(`  Memorias: ${res.memories.length}`);
+  if (res.contextFiles?.length > 0)
+    console.error(`  Context Files: ${res.contextFiles.length}`);
+  if (redactedVars.length > 0) {
+    console.error(`  Variables redactadas: ${redactedVars.join(", ")}`);
+  }
+  if (includedVars.length > 0) {
+    console.error(`  Variables incluidas: ${includedVars.join(", ")}`);
+  }
+  if (gitignoreAdded) {
+    console.error("  \u2705 .aci/ a\xF1adido al .gitignore");
+  }
+  if (bundle.warnings.length > 0) {
+    console.error("\n  Advertencias:");
+    for (const w of bundle.warnings) {
+      console.error(`    \u26A0\uFE0F ${w}`);
+    }
+  }
+}
+async function promptAutoImport(rl) {
+  console.error("\nSe detect\xF3 un bundle de ecosistema AI en .aci/");
+  while (true) {
+    const answer = await rl.question("\xBFQuieres importarlo? [s/N]: ");
+    const trimmed = answer.trim();
+    if (trimmed === "") return false;
+    const parsed = parseYesNo(trimmed);
+    if (parsed !== void 0) return parsed;
+    console.error("  Entrada inv\xE1lida. Usa s (s\xED) o n (no).");
+  }
+}
+
+// src/cli.ts
 function parseCliArgs(argv) {
   const { values } = parseArgs({
     args: argv,
@@ -38,14 +381,54 @@ function parseCliArgs(argv) {
     timeout: parseInt(values.timeout ?? "10000", 10)
   };
 }
+function parseExportArgs(argv) {
+  const { values } = parseArgs({
+    args: argv,
+    options: {
+      dir: { type: "string", short: "d" },
+      output: { type: "string", short: "o" },
+      "include-user": { type: "boolean", default: false },
+      only: { type: "string" },
+      secrets: { type: "string" },
+      help: { type: "boolean", short: "h", default: false }
+    },
+    strict: false,
+    allowPositionals: true
+  });
+  return values;
+}
+function parseImportArgs(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    options: {
+      dir: { type: "string", short: "d" },
+      target: { type: "string" },
+      scope: { type: "string" },
+      force: { type: "boolean", default: false },
+      yes: { type: "boolean", default: false },
+      only: { type: "string" },
+      secrets: { type: "string" },
+      help: { type: "boolean", short: "h", default: false }
+    },
+    strict: false,
+    allowPositionals: true
+  });
+  return { values, positionals };
+}
 function printHelp() {
   console.error(`
   ai-context-inspector \u2014 Escanea el ecosistema AI de un proyecto
 
   Uso:
     npx @cocaxcode/ai-context-inspector [opciones]
+    npx @cocaxcode/ai-context-inspector export [opciones]
+    npx @cocaxcode/ai-context-inspector import [archivo] [opciones]
 
-  Opciones:
+  Subcomandos:
+    export              Exportar ecosistema AI a bundle portable (.aci/)
+    import [archivo]    Importar bundle a otra herramienta AI
+
+  Opciones generales:
     -d, --dir <ruta>       Directorio a escanear (default: cwd)
     -o, --output <ruta>    Archivo HTML de salida (default: ai-context-report.html)
     --json                 Output JSON en stdout (no genera HTML)
@@ -54,9 +437,260 @@ function printHelp() {
     --timeout <ms>         Timeout de introspecci\xF3n MCP (default: 10000)
     --mcp                  Arrancar como MCP server
     -h, --help             Mostrar ayuda
+
+  Opciones de export:
+    -d, --dir <ruta>       Directorio a exportar (default: cwd)
+    -o, --output <ruta>    Directorio de salida (default: .aci/)
+    --include-user         Incluir configuraci\xF3n del directorio de usuario
+    --only <categor\xEDas>    Solo exportar: mcp,skills,agents,memories,context
+    --secrets <modo>       Modo de secretos: none | all (default: interactivo)
+
+  Opciones de import:
+    -d, --dir <ruta>       Directorio destino (default: cwd)
+    --target <tool>        Herramienta destino: claude|cursor|windsurf|copilot|gemini|codex|opencode
+    --scope <scope>        Scope: project | user
+    --force                Sobreescribir recursos existentes
+    --yes                  Saltar confirmaci\xF3n
+    --only <categor\xEDas>    Solo importar: mcp,skills,agents,memories,context
+    --secrets <modo>       Modo de secretos: none | all (default: interactivo)
+`);
+}
+function printExportHelp() {
+  console.error(`
+  ai-context-inspector export \u2014 Exportar ecosistema AI a bundle portable
+
+  Uso:
+    npx @cocaxcode/ai-context-inspector export [opciones]
+
+  Opciones:
+    -d, --dir <ruta>       Directorio a exportar (default: cwd)
+    -o, --output <ruta>    Directorio de salida (default: .aci/)
+    --include-user         Incluir configuraci\xF3n del directorio de usuario
+    --only <categor\xEDas>    Solo exportar: mcp,skills,agents,memories,context
+    --secrets <modo>       Modo de secretos: none | all (default: interactivo)
+    -h, --help             Mostrar ayuda
 `);
 }
-async function runCli(options) {
+function printImportHelp() {
+  console.error(`
+  ai-context-inspector import \u2014 Importar bundle a otra herramienta AI
+
+  Uso:
+    npx @cocaxcode/ai-context-inspector import [archivo] [opciones]
+
+  Argumentos:
+    archivo                Ruta al bundle (default: auto-detecta .aci/bundle.json)
+
+  Opciones:
+    -d, --dir <ruta>       Directorio destino (default: cwd)
+    --target <tool>        Herramienta destino: claude|cursor|windsurf|copilot|gemini|codex|opencode
+    --scope <scope>        Scope: project | user
+    --force                Sobreescribir recursos existentes
+    --yes                  Saltar confirmaci\xF3n
+    --only <categor\xEDas>    Solo importar: mcp,skills,agents,memories,context
+    --secrets <modo>       Modo de secretos: none | all (default: interactivo)
+    -h, --help             Mostrar ayuda
+`);
+}
+function parseOnlyFlag(onlyStr) {
+  if (!onlyStr) return void 0;
+  return onlyStr.split(",").map((s) => s.trim());
+}
+async function runExport(argv) {
+  const values = parseExportArgs(argv);
+  if (values.help) {
+    printExportHelp();
+    process.exit(0);
+  }
+  const dir = resolve(values.dir ?? process.cwd());
+  try {
+    await access(dir);
+  } catch {
+    console.error(`Error: El directorio no existe: ${dir}`);
+    process.exit(1);
+  }
+  const includeUser = values["include-user"] ?? false;
+  const onlyFlag = parseOnlyFlag(values.only);
+  const secretsFlag = values.secrets;
+  console.error(`Escaneando ${dir}...`);
+  const scan = await runAllScanners({
+    dir,
+    includeUser,
+    introspect: false,
+    timeout: 5e3
+  });
+  const available = [];
+  if (scan.mcpServers.length > 0) available.push({ category: "mcp", count: scan.mcpServers.length });
+  if (scan.skills.length > 0) available.push({ category: "skills", count: scan.skills.length });
+  if (scan.agents.length > 0) available.push({ category: "agents", count: scan.agents.length });
+  if (scan.memories.length > 0) available.push({ category: "memories", count: scan.memories.length });
+  if (scan.contextFiles.length > 0) available.push({ category: "context", count: scan.contextFiles.length });
+  if (available.length === 0) {
+    console.error("No se encontraron recursos AI para exportar.");
+    return;
+  }
+  let only = onlyFlag;
+  if (!only) {
+    const rl = createPromptInterface();
+    try {
+      only = await promptCategories(rl, available, "exportar");
+    } finally {
+      rl.close();
+    }
+  }
+  let secretsMode;
+  let secretDecisions;
+  if (secretsFlag === "none" || secretsFlag === "all") {
+    secretsMode = secretsFlag;
+  } else {
+    const detectedVars = detectEnvVars(scan.mcpServers);
+    if (detectedVars.length === 0) {
+      secretsMode = "none";
+    } else {
+      const rl = createPromptInterface();
+      try {
+        const result = await promptExportSecrets(rl, detectedVars);
+        secretsMode = result.mode;
+        secretDecisions = result.decisions;
+      } finally {
+        rl.close();
+      }
+    }
+  }
+  const exportOptions = {
+    dir,
+    includeUser,
+    only,
+    secrets: secretsMode,
+    secretDecisions
+  };
+  const bundle = await exportEcosystem(exportOptions);
+  const allRedacted = [];
+  const allIncluded = [];
+  for (const server of bundle.resources.mcpServers) {
+    allRedacted.push(...server.envVarsRedacted);
+    allIncluded.push(...server.envVarsIncluded);
+  }
+  printExportResult(bundle, allRedacted, allIncluded, true);
+}
+async function runImport(argv) {
+  const { values, positionals } = parseImportArgs(argv);
+  if (values.help) {
+    printImportHelp();
+    process.exit(0);
+  }
+  const dir = resolve(values.dir ?? process.cwd());
+  const bundleFile = positionals[0] ?? void 0;
+  const targetFlag = values.target;
+  const scopeFlag = values.scope;
+  const forceFlag = values.force ?? false;
+  const yesFlag = values.yes ?? false;
+  const onlyFlag = parseOnlyFlag(values.only);
+  const secretsFlag = values.secrets;
+  console.error("Cargando bundle...");
+  const bundle = await loadBundle(bundleFile, dir);
+  console.error(`Bundle cargado: ${bundle.sourceProject} (${bundle.createdAt})`);
+  const available = [];
+  const r = bundle.resources;
+  if (r.mcpServers.length > 0) available.push({ category: "mcp", count: r.mcpServers.length });
+  if (r.skills.length > 0) available.push({ category: "skills", count: r.skills.length });
+  if (r.agents.length > 0) available.push({ category: "agents", count: r.agents.length });
+  if (r.memories.length > 0) available.push({ category: "memories", count: r.memories.length });
+  if (r.contextFiles.length > 0) available.push({ category: "context", count: r.contextFiles.length });
+  if (available.length === 0) {
+    console.error("El bundle no contiene recursos para importar.");
+    return;
+  }
+  let only = onlyFlag;
+  if (!only) {
+    const rl = createPromptInterface();
+    try {
+      only = await promptCategories(rl, available, "importar");
+    } finally {
+      rl.close();
+    }
+  }
+  let target = targetFlag;
+  if (!target) {
+    const detected = await detectTargetTools(dir);
+    if (detected.length === 1) {
+      target = detected[0];
+      console.error(`Herramienta detectada: ${target}`);
+    } else {
+      const rl = createPromptInterface();
+      try {
+        target = await promptTargetTool(rl, detected);
+      } finally {
+        rl.close();
+      }
+    }
+  }
+  let secretValues;
+  if (secretsFlag !== "none" && secretsFlag !== "all") {
+    const envVarsIncluded = [];
+    const envVarsRedacted = [];
+    const envValues = {};
+    for (const server of r.mcpServers) {
+      envVarsIncluded.push(...server.envVarsIncluded);
+      envVarsRedacted.push(...server.envVarsRedacted);
+      if (server.config.env) {
+        for (const [k, v] of Object.entries(server.config.env)) {
+          if (server.envVarsIncluded.includes(k)) {
+            envValues[k] = v;
+          }
+        }
+      }
+    }
+    if (envVarsIncluded.length > 0 || envVarsRedacted.length > 0) {
+      const rl = createPromptInterface();
+      try {
+        const result2 = await promptImportSecrets(rl, { envVarsIncluded, envVarsRedacted, envValues });
+        if (result2.values) {
+          secretValues = result2.values;
+        }
+      } finally {
+        rl.close();
+      }
+    }
+  } else if (secretsFlag === "none") {
+    secretValues = void 0;
+  }
+  const importOptions = {
+    file: bundleFile,
+    dir,
+    target,
+    scope: scopeFlag,
+    force: forceFlag,
+    confirm: yesFlag,
+    only,
+    secrets: secretsFlag ?? "none",
+    secretValues
+  };
+  const plan = await planImport(bundle, importOptions);
+  if (!yesFlag) {
+    const rl = createPromptInterface();
+    try {
+      const confirmed = await promptConfirmPlan(rl, plan);
+      if (!confirmed) {
+        console.error("Importaci\xF3n cancelada.");
+        return;
+      }
+    } finally {
+      rl.close();
+    }
+  }
+  const result = await executeImport(plan, bundle, importOptions);
+  printImportResult(result);
+}
+async function runCli(argv) {
+  const subcommand = argv[0];
+  if (subcommand === "export") {
+    return runExport(argv.slice(1));
+  }
+  if (subcommand === "import") {
+    return runImport(argv.slice(1));
+  }
+  const options = parseCliArgs(argv);
   const dir = resolve(options.dir);
   try {
     await access(dir);
@@ -90,20 +724,35 @@ Escaneo completado en ${result.scanDuration}ms
   Warnings: ${result.warnings.length}
 
 Reporte: ${outputPath}`);
+  const aciPath = join(dir, ACI_DIR, ACI_BUNDLE);
+  try {
+    await access(aciPath);
+    const rl = createPromptInterface();
+    try {
+      const shouldImport = await promptAutoImport(rl);
+      if (shouldImport) {
+        await runImport([]);
+      }
+    } finally {
+      rl.close();
+    }
+  } catch {
+  }
 }
 
 // src/index.ts
 async function main() {
-  const options = parseCliArgs(process.argv.slice(2));
-  if (options.mcp) {
+  const argv = process.argv.slice(2);
+  const hasMcpFlag = argv.includes("--mcp");
+  if (hasMcpFlag) {
     const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
-    const { createServer } = await import("./server-BSHVSE33.js");
+    const { createServer } = await import("./server-22Y7DPSM.js");
     const server = createServer();
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error("ai-context-inspector MCP server running on stdio");
   } else {
-    await runCli(options);
+    await runCli(argv);
   }
 }
 main().catch((error) => {