nexus-agents 2.26.1 → 2.28.0

package/dist/{chunk-UVQ7R4C4.js → chunk-YSDUVCCZ.js}

@@ -1,35 +1,22 @@
 import {
   VERSION,
-  capitalize,
-  createAllAdapters,
-  createServer
-} from "./chunk-ARNVVQ5W.js";
+  initDataDirectories
+} from "./chunk-LKSTILEE.js";
 import {
   runConfigInitSync
-} from "./chunk-LCHCASB7.js";
+} from "./chunk-UGNLR4NZ.js";
 import {
-  CLI_SUBPROCESS_TIMEOUTS
-} from "./chunk-LCDOP543.js";
-import {
-  DEFAULT_CAPABILITIES,
-  DEFAULT_MODEL_CAPABILITIES,
-  LEARNING_DIR,
-  OUTCOMES_FILE,
-  RULES_FILE,
-  colors,
+  CLI_SUBPROCESS_TIMEOUTS,
   createLogger,
   formatCodeBlock,
   formatHeader,
   formatStatus,
   getErrorMessage,
-  getTimeProvider,
-  isPersistenceEnabled,
-  symbols,
-  writeLine
-} from "./chunk-BOWNZMPH.js";
+  getTimeProvider
+} from "./chunk-L2SHSW4T.js";
 
 // src/cli/setup-command.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 
 // src/cli/setup-types.ts
 import { z } from "zod";
@@ -160,7 +147,8 @@ function detectProjectInfo(root) {
     try {
       const content = readFileSync(join(root, "package.json"), "utf-8");
       const pkg = JSON.parse(content);
-      packageName = pkg["name"];
+      const nameValue = pkg["name"];
+      packageName = typeof nameValue === "string" ? nameValue : void 0;
     } catch (parseErr) {
       void parseErr;
     }
@@ -500,606 +488,11 @@ function isInteractive() {
   return true;
 }
 
-// src/cli/setup-data-dir.ts
-import { mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join5 } from "path";
-
-// src/cli/doctor.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3, accessSync, constants as fsConstants } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
-
-// src/cli/doctor-formatting.ts
-var REQUIRED_NODE_MAJOR = 22;
-function formatStatus2(healthy, warn = false) {
-  if (healthy) return `${colors.green}${symbols.check}${colors.reset}`;
-  if (warn) return `${colors.yellow}${symbols.warn}${colors.reset}`;
-  return `${colors.red}${symbols.cross}${colors.reset}`;
-}
-function formatVersionStatus(status) {
-  switch (status) {
-    case "supported":
-      return `${colors.green}supported${colors.reset}`;
-    case "outdated":
-      return `${colors.yellow}outdated${colors.reset}`;
-    case "unsupported":
-    case "breaking":
-      return `${colors.red}${status}${colors.reset}`;
-    default:
-      return status;
-  }
-}
-function formatCapacity(capacity) {
-  if (capacity === void 0) return "Unknown";
-  const remaining = 100 - capacity.utilizationPercent;
-  const remainingStr = String(remaining);
-  if (remaining > 80) return `${colors.green}${remainingStr}% remaining${colors.reset}`;
-  if (remaining > 20) return `${colors.yellow}${remainingStr}% remaining${colors.reset}`;
-  return `${colors.red}${remainingStr}% remaining${colors.reset}`;
-}
-function printInstalledCliDetails(cli) {
-  writeLine(`  Version: ${cli.version} (${formatVersionStatus(cli.versionStatus)})`);
-  const authText = cli.authenticated ? `${colors.green}${cli.authMethod ?? "Authenticated"}${colors.reset}` : `${colors.red}Not authenticated${colors.reset}`;
-  writeLine(`  Auth: ${authText}`);
-  if (cli.capacity !== void 0) {
-    writeLine(`  Capacity: ${formatCapacity(cli.capacity)}`);
-  }
-}
-function printCliResult(cli) {
-  const status = cli.installed && cli.authenticated;
-  const warn = cli.installed && (!cli.authenticated || cli.versionStatus === "outdated");
-  writeLine(
-    `${formatStatus2(status, warn)} ${colors.bold}${capitalize(cli.name)} CLI${colors.reset}`
-  );
-  if (cli.installed) {
-    printInstalledCliDetails(cli);
-  } else {
-    const errorText = cli.error ?? "Not installed";
-    writeLine(`  ${colors.red}Error: ${errorText}${colors.reset}`);
-  }
-  if (cli.fix !== void 0 && cli.fix !== "") {
-    writeLine(`  ${colors.dim}Fix: ${cli.fix}${colors.reset}`);
-  }
-  writeLine("");
-}
-function printCapabilities(clis) {
-  const installedClis = clis.filter((c) => c.installed);
-  if (installedClis.length === 0) {
-    writeLine(`${formatStatus2(false)} No CLIs installed`);
-    return;
-  }
-  const caps = DEFAULT_CAPABILITIES;
-  const bestReasoning = installedClis.reduce(
-    (best, c) => caps[c.name].reasoning > caps[best.name].reasoning ? c : best
-  );
-  const bestContext = installedClis.reduce(
-    (best, c) => caps[c.name].contextWindow > caps[best.name].contextWindow ? c : best
-  );
-  const bestSpeed = installedClis.reduce(
-    (best, c) => caps[c.name].speed > caps[best.name].speed ? c : best
-  );
-  const contextTokensK = (caps[bestContext.name].contextWindow / 1e3).toFixed(0);
-  writeLine(
-    `${formatStatus2(true)} Complex reasoning: ${colors.bold}${capitalize(bestReasoning.name)}${colors.reset}`
-  );
-  writeLine(
-    `${formatStatus2(true)} Large context: ${colors.bold}${capitalize(bestContext.name)}${colors.reset} (${contextTokensK}K tokens)`
-  );
-  writeLine(
-    `${formatStatus2(true)} Fast execution: ${colors.bold}${capitalize(bestSpeed.name)}${colors.reset}`
-  );
-}
-function printNodeVersionCheck(check) {
-  const versionText = check.supported ? `${colors.green}${check.version}${colors.reset}` : `${colors.yellow}${check.version}${colors.reset}`;
-  writeLine(`${formatStatus2(check.supported, !check.supported)} Node.js version: ${versionText}`);
-  if (!check.supported) {
-    writeLine(
-      `  ${colors.dim}Warning: Node.js ${String(REQUIRED_NODE_MAJOR)}.x LTS required${colors.reset}`
-    );
-  }
-}
-function printApiKeysCheck(keys) {
-  const configuredCount = keys.filter((k) => k.configured).length;
-  const configuredNames = keys.filter((k) => k.configured).map((k) => k.name);
-  const hasAny = configuredCount > 0;
-  writeLine(
-    `${formatStatus2(hasAny, !hasAny)} API keys configured: ${String(configuredCount)} of ${String(keys.length)}`
-  );
-  if (hasAny) {
-    writeLine(`  ${colors.dim}Keys: ${configuredNames.join(", ")}${colors.reset}`);
-  } else {
-    writeLine(
-      `  ${colors.dim}Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GOOGLE_AI_API_KEY${colors.reset}`
-    );
-  }
-}
-function printConfigFileCheck(check) {
-  if (check.found && check.path !== null) {
-    writeLine(`${formatStatus2(true)} Configuration loaded: ${check.path}`);
-  } else {
-    writeLine(`${formatStatus2(false, true)} Configuration file: Not found`);
-    writeLine(`  ${colors.dim}Run: nexus-agents config init${colors.reset}`);
-  }
-}
-function printRegistryAdvisory(advisory) {
-  const allAvailable = advisory.unavailableModels === 0;
-  const countText = `${String(advisory.availableModels)} of ${String(advisory.totalModels)}`;
-  writeLine(`${formatStatus2(allAvailable, !allAvailable)} Models available: ${countText}`);
-  if (advisory.unavailableModels > 0) {
-    const missing = advisory.models.filter((m) => !m.available);
-    for (const m of missing) {
-      writeLine(`  ${colors.dim}${m.displayName} \u2014 ${m.reason}${colors.reset}`);
-    }
-  }
-}
-function printLearningPersistence(check) {
-  if (!check.enabled) {
-    writeLine(`${formatStatus2(true)} Learning persistence: ${colors.dim}Disabled${colors.reset}`);
-    writeLine(`  ${colors.dim}Set NEXUS_PERSIST_LEARNING=true to enable${colors.reset}`);
-    return;
-  }
-  const healthy = check.dirExists && check.dirWritable && check.error === null;
-  writeLine(`${formatStatus2(healthy, !healthy)} Learning persistence: Enabled`);
-  if (check.error !== null) {
-    writeLine(`  ${colors.red}Error: ${check.error}${colors.reset}`);
-    return;
-  }
-  const dirStatus = check.dirExists ? check.dirWritable ? `${colors.green}writable${colors.reset}` : `${colors.red}not writable${colors.reset}` : `${colors.yellow}not created yet${colors.reset}`;
-  writeLine(`  Data directory: ${dirStatus}`);
-  writeLine(`  Outcomes: ${String(check.outcomeCount)} recorded`);
-  writeLine(`  Distilled rules: ${String(check.ruleCount)} active`);
-  if (check.rulesLastSaved !== null) {
-    writeLine(`  Rules last saved: ${check.rulesLastSaved}`);
-  }
-}
-function printSqliteCheck(check) {
-  if (check.available) {
-    writeLine(
-      `${formatStatus2(true)} SQLite (better-sqlite3): ${colors.green}Available${colors.reset}`
-    );
-  } else {
-    writeLine(
-      `${formatStatus2(false, true)} SQLite (better-sqlite3): ${colors.yellow}Not available${colors.reset}`
-    );
-    writeLine(
-      `  ${colors.dim}Memory backends (agentic, adaptive, typed) require it${colors.reset}`
-    );
-    writeLine(`  ${colors.dim}Fix: npm install -g better-sqlite3${colors.reset}`);
-  }
-}
-function printDataDirectory(check) {
-  if (check.rootExists) {
-    const existCount = check.subdirectories.filter((d) => d.exists).length;
-    const totalCount = check.subdirectories.length;
-    const allExist = existCount === totalCount;
-    writeLine(
-      `${formatStatus2(allExist, !allExist)} Data directory: ${check.rootPath} (${String(existCount)}/${String(totalCount)} subdirs)`
-    );
-    if (!allExist) {
-      const missing = check.subdirectories.filter((d) => !d.exists);
-      for (const dir of missing) {
-        writeLine(`  ${colors.dim}Missing: ${dir.name}/${colors.reset}`);
-      }
-      writeLine(`  ${colors.dim}Fix: nexus-agents setup${colors.reset}`);
-    }
-  } else {
-    writeLine(
-      `${formatStatus2(false, true)} Data directory: ${colors.yellow}Not created${colors.reset}`
-    );
-    writeLine(`  ${colors.dim}Run: nexus-agents setup${colors.reset}`);
-  }
-}
-function printDoctorSummary(result) {
-  const unhealthyCount = result.clis.filter((c) => !c.installed || !c.authenticated).length;
-  const nodeIssue = result.nodeVersion.supported ? 0 : 1;
-  const totalIssues = unhealthyCount + nodeIssue + (result.mcpServerReady ? 0 : 1);
-  const summary = result.allHealthy ? `${colors.green}${colors.bold}Status: Ready${colors.reset}` : `${colors.yellow}${colors.bold}Summary: ${String(totalIssues)} issue(s) found${colors.reset}`;
-  writeLine(summary);
-  writeLine("");
-}
-function printDoctorResults(result) {
-  writeLine("");
-  writeLine(`${colors.bold}Nexus Agents Doctor${colors.reset}`);
-  writeLine("===================");
-  writeLine("");
-  writeLine(`${colors.cyan}Checking environment...${colors.reset}`);
-  writeLine("");
-  printNodeVersionCheck(result.nodeVersion);
-  printApiKeysCheck(result.apiKeys);
-  printConfigFileCheck(result.configFile);
-  writeLine("");
-  writeLine(`${colors.cyan}Checking CLI installations...${colors.reset}`);
-  writeLine("");
-  for (const cli of result.clis) {
-    printCliResult(cli);
-  }
-  writeLine(`${colors.cyan}Checking MCP configuration...${colors.reset}`);
-  writeLine("");
-  writeLine(
-    `${formatStatus2(result.mcpServerReady)} MCP Server mode: ${result.mcpServerReady ? "Ready" : "Not ready"}`
-  );
-  writeLine(
-    `${formatStatus2(result.mcpClientReady)} MCP Client mode: ${result.mcpClientReady ? "Ready (Codex mcp-server)" : "Not ready (Codex not installed)"}`
-  );
-  writeLine("");
-  writeLine(`${colors.cyan}Checking capabilities...${colors.reset}`);
-  writeLine("");
-  printCapabilities(result.clis);
-  writeLine("");
-  writeLine(`${colors.cyan}Checking model registry...${colors.reset}`);
-  writeLine("");
-  printRegistryAdvisory(result.registryAdvisory);
-  writeLine("");
-  writeLine(`${colors.cyan}Checking learning subsystem...${colors.reset}`);
-  writeLine("");
-  printLearningPersistence(result.learningPersistence);
-  writeLine("");
-  writeLine(`${colors.cyan}Checking data storage...${colors.reset}`);
-  writeLine("");
-  printSqliteCheck(result.sqliteCheck);
-  printDataDirectory(result.dataDirectory);
-  writeLine("");
-  printDoctorSummary(result);
-}
-
-// src/cli/doctor.ts
-var REQUIRED_NODE_MAJOR2 = 22;
-var API_KEY_VARS = ["ANTHROPIC_API_KEY", "OPENAI_API_KEY", "GOOGLE_AI_API_KEY"];
-var CONFIG_FILE_PATHS = ["./nexus-agents.yaml", "./nexus-agents.yml"];
-var DATA_SUBDIRECTORIES = [
-  "memory",
-  "memory/beliefs",
-  "learning",
-  "sessions",
-  "audit",
-  "voting",
-  "auth",
-  "research",
-  "checkpoints"
-];
-function getFixCommand(name, issue) {
-  const commands = {
-    claude: {
-      install: "npm install -g @anthropic-ai/claude-code",
-      upgrade: "npm update -g @anthropic-ai/claude-code",
-      auth: "claude auth login"
-    },
-    gemini: {
-      install: "npm install -g @google/gemini-cli",
-      upgrade: "npm update -g @google/gemini-cli",
-      auth: "gemini auth login"
-    },
-    codex: {
-      install: "npm install -g @openai/codex",
-      upgrade: "npm update -g @openai/codex",
-      auth: "codex auth login"
-    },
-    opencode: {
-      install: "npm install -g opencode-ai",
-      upgrade: "npm update -g opencode-ai",
-      auth: "opencode auth login"
-    }
-  };
-  return commands[name][issue] ?? "";
-}
-function createNotFoundResult(name, errorMsg) {
-  return {
-    name,
-    installed: false,
-    version: "N/A",
-    versionStatus: "unsupported",
-    authenticated: false,
-    error: errorMsg,
-    fix: getFixCommand(name, "install")
-  };
-}
-function detectAuthMethod(name) {
-  const authMethods = {
-    claude: "CLI auth",
-    gemini: "ADC/CLI auth",
-    codex: "CLI auth",
-    opencode: "CLI auth"
-  };
-  return authMethods[name];
-}
-function createHealthyResult(name, health, capacity) {
-  const authenticated = health.healthy;
-  const result = {
-    name,
-    installed: true,
-    version: health.version,
-    versionStatus: health.versionStatus,
-    authenticated,
-    ...authenticated && { authMethod: detectAuthMethod(name) },
-    ...capacity !== void 0 && { capacity }
-  };
-  if (health.message !== void 0 && health.message !== "") {
-    return { ...result, error: health.message };
-  }
-  if (!authenticated) {
-    return { ...result, fix: getFixCommand(name, "auth") };
-  }
-  if (health.versionStatus === "outdated") {
-    return { ...result, fix: getFixCommand(name, "upgrade") };
-  }
-  return result;
-}
-async function checkCli(name) {
-  const adapters = createAllAdapters();
-  const adapter = adapters.get(name);
-  if (!adapter) {
-    return createNotFoundResult(name, "Adapter not available");
-  }
-  try {
-    const health = await adapter.healthCheck();
-    let capacity;
-    try {
-      capacity = await adapter.getCapacity();
-    } catch (capErr) {
-      void capErr;
-    }
-    return createHealthyResult(name, health, capacity);
-  } catch (error) {
-    const message = getErrorMessage(error);
-    const isNotFound = message.includes("ENOENT") || message.includes("not found");
-    return createNotFoundResult(name, isNotFound ? "Not found in PATH" : message);
-  }
-}
-function checkNodeVersion() {
-  const version = process.version;
-  const major = Number(version.slice(1).split(".")[0]);
-  return {
-    version,
-    major,
-    supported: major >= REQUIRED_NODE_MAJOR2
-  };
-}
-function checkApiKeys() {
-  return API_KEY_VARS.map((name) => ({
-    name,
-    configured: typeof process.env[name] === "string" && process.env[name] !== ""
-  }));
-}
-function checkConfigFile() {
-  for (const configPath of CONFIG_FILE_PATHS) {
-    if (existsSync2(configPath)) {
-      return { found: true, path: configPath };
-    }
-  }
-  return { found: false, path: null };
-}
-function checkMcpServerReady() {
-  try {
-    const result = createServer({ name: "nexus-agents-doctor-check" });
-    return result.ok;
-  } catch {
-    return false;
-  }
-}
-function buildRegistryAdvisory(cliResults) {
-  const installedClis = new Set(cliResults.filter((c) => c.installed).map((c) => c.name));
-  const models = DEFAULT_MODEL_CAPABILITIES.models.filter((m) => m.cliName !== void 0).map((m) => {
-    const cliName = m.cliName;
-    const available = installedClis.has(cliName);
-    const reason = available ? `${cliName} CLI is installed` : `${cliName} CLI is not installed`;
-    return { modelId: m.id, displayName: m.displayName, cliName, available, reason };
-  });
-  return {
-    totalModels: models.length,
-    availableModels: models.filter((m) => m.available).length,
-    unavailableModels: models.filter((m) => !m.available).length,
-    models
-  };
-}
-function countJsonlLines(filePath) {
-  if (!existsSync2(filePath)) return 0;
-  return readFileSync3(filePath, "utf-8").split("\n").filter((l) => l.trim().length > 0).length;
-}
-function readRulesMetadata(filePath) {
-  if (!existsSync2(filePath)) return { count: 0, savedAt: null };
-  try {
-    const raw = JSON.parse(readFileSync3(filePath, "utf-8"));
-    const rules = raw["rules"];
-    const saved = raw["savedAt"];
-    return {
-      count: Array.isArray(rules) ? rules.length : 0,
-      savedAt: typeof saved === "string" ? saved : null
-    };
-  } catch {
-    return { count: 0, savedAt: null };
-  }
-}
-function checkDirAccess(dir) {
-  const exists = existsSync2(dir);
-  if (!exists) return { exists: false, writable: false };
-  try {
-    accessSync(dir, fsConstants.W_OK);
-    return { exists: true, writable: true };
-  } catch {
-    return { exists: true, writable: false };
-  }
-}
-var DISABLED_CHECK = {
-  enabled: false,
-  dirExists: false,
-  dirWritable: false,
-  outcomeCount: 0,
-  ruleCount: 0,
-  rulesLastSaved: null,
-  error: null
-};
-function checkLearningPersistence() {
-  if (!isPersistenceEnabled()) return DISABLED_CHECK;
-  try {
-    const { exists: dirExists, writable: dirWritable } = checkDirAccess(LEARNING_DIR);
-    const outcomeCount = countJsonlLines(OUTCOMES_FILE);
-    const { count: ruleCount, savedAt: rulesLastSaved } = readRulesMetadata(RULES_FILE);
-    return {
-      enabled: true,
-      dirExists,
-      dirWritable,
-      outcomeCount,
-      ruleCount,
-      rulesLastSaved,
-      error: null
-    };
-  } catch (error) {
-    return {
-      enabled: true,
-      dirExists: false,
-      dirWritable: false,
-      outcomeCount: 0,
-      ruleCount: 0,
-      rulesLastSaved: null,
-      error: getErrorMessage(error)
-    };
-  }
-}
-async function checkSqlite() {
-  try {
-    await import("better-sqlite3");
-    return { available: true, error: null };
-  } catch (error) {
-    const msg = getErrorMessage(error);
-    const isNotFound = msg.includes("Cannot find") || msg.includes("MODULE_NOT_FOUND");
-    return {
-      available: false,
-      error: isNotFound ? "better-sqlite3 not installed \u2014 5 memory backends unavailable" : `better-sqlite3 load error: ${msg}`
-    };
-  }
-}
-function checkDataDirectory() {
-  const rootPath = join4(homedir3(), ".nexus-agents");
-  const rootExists = existsSync2(rootPath);
-  const subdirectories = DATA_SUBDIRECTORIES.map((name) => {
-    const fullPath = join4(rootPath, name);
-    return { name, path: fullPath, exists: existsSync2(fullPath) };
-  });
-  return { rootExists, rootPath, subdirectories };
-}
-async function runDoctor() {
-  const clis = await Promise.all([
-    checkCli("claude"),
-    checkCli("gemini"),
-    checkCli("codex"),
-    checkCli("opencode")
-  ]);
-  const nodeVersion = checkNodeVersion();
-  const apiKeys = checkApiKeys();
-  const configFile = checkConfigFile();
-  const mcpServerReady = checkMcpServerReady();
-  const codexCheck = clis.find((c) => c.name === "codex");
-  const mcpClientReady = codexCheck?.installed ?? false;
-  const registryAdvisory = buildRegistryAdvisory(clis);
-  const learningPersistence = checkLearningPersistence();
-  const sqliteCheck = await checkSqlite();
-  const dataDirectory = checkDataDirectory();
-  const hasAuthMethod = apiKeys.some((k) => k.configured) || clis.some((c) => c.installed && c.authenticated);
-  const allHealthy = nodeVersion.supported && hasAuthMethod && mcpServerReady && clis.every((c) => c.installed && c.authenticated && c.versionStatus !== "unsupported");
-  return {
-    clis,
-    nodeVersion,
-    apiKeys,
-    configFile,
-    mcpServerReady,
-    mcpClientReady,
-    registryAdvisory,
-    learningPersistence,
-    sqliteCheck,
-    dataDirectory,
-    allHealthy,
-    timestamp: new Date(getTimeProvider().now())
-  };
-}
-async function doctorCommand(options = {}) {
-  const result = await runDoctor();
-  printDoctorResults(result);
-  if (options.fix === true) {
-    await runDoctorFix(result);
-  }
-  return result.allHealthy ? 0 : 1;
-}
-async function runDoctorFix(result) {
-  const writeLine4 = (text) => {
-    process.stdout.write(text + "\n");
-  };
-  writeLine4("");
-  writeLine4("\x1B[1mAuto-fix\x1B[0m");
-  writeLine4("\u2500".repeat(40));
-  let fixCount = 0;
-  if (!result.dataDirectory.rootExists || result.dataDirectory.subdirectories.some((d) => !d.exists)) {
-    const { runSetup: runSetup2 } = await import("./setup-command-VNF3KTCJ.js");
-    const setupResult = runSetup2({
-      skipMcp: true,
-      skipRules: true,
-      skipHooks: true,
-      skipConfig: true,
-      skipOpencode: true
-    });
-    if (setupResult.success) {
-      writeLine4("\u2713 Created missing data directories");
-      fixCount++;
-    }
-  }
-  if (!result.configFile.found) {
-    const { runConfigInitSync: runConfigInitSync2 } = await import("./setup-config-VQSWWJ5O.js");
-    const configResult = runConfigInitSync2(process.cwd(), false, false);
-    if (configResult.success && configResult.created) {
-      writeLine4(`\u2713 Generated config: ${configResult.path}`);
-      fixCount++;
-    }
-  }
-  if (!result.sqliteCheck.available) {
-    writeLine4("");
-    writeLine4("\u26A0 better-sqlite3 not installed (manual step required):");
-    writeLine4("  npm install -g better-sqlite3");
-  }
-  if (fixCount > 0) {
-    writeLine4("");
-    writeLine4(
-      `\x1B[32m${String(fixCount)} issue(s) fixed.\x1B[0m Re-run \x1B[1mnexus-agents doctor\x1B[0m to verify.`
-    );
-  } else {
-    writeLine4("No auto-fixable issues found.");
-  }
-  writeLine4("");
-}
-
-// src/cli/setup-data-dir.ts
-var NEXUS_DATA_DIR = join5(homedir4(), ".nexus-agents");
-var RESTRICTED_DIRS = /* @__PURE__ */ new Set(["auth"]);
-function initDataDirectories(dryRun = false) {
-  const created = [];
-  const alreadyExisted = [];
-  try {
-    ensureDir(NEXUS_DATA_DIR, dryRun, created, alreadyExisted);
-    for (const subdir of DATA_SUBDIRECTORIES) {
-      const mode = RESTRICTED_DIRS.has(subdir) ? 448 : void 0;
-      ensureDir(join5(NEXUS_DATA_DIR, subdir), dryRun, created, alreadyExisted, mode);
-    }
-    return { success: true, rootPath: NEXUS_DATA_DIR, created, alreadyExisted, error: null };
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    return { success: false, rootPath: NEXUS_DATA_DIR, created, alreadyExisted, error: msg };
-  }
-}
-function ensureDir(dirPath, dryRun, created, alreadyExisted, mode) {
-  if (existsSync3(dirPath)) {
-    alreadyExisted.push(dirPath);
-    return;
-  }
-  if (!dryRun) {
-    mkdirSync2(dirPath, { recursive: true, ...mode !== void 0 ? { mode } : {} });
-  }
-  created.push(dirPath);
-}
-
 // src/cli/setup-opencode.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
 import { execFileSync as execFileSync2 } from "child_process";
-import { join as join6, resolve } from "path";
-import { homedir as homedir5, platform } from "os";
+import { join as join4, resolve } from "path";
+import { homedir as homedir3, platform } from "os";
 import { parse as jsoncParse, modify, applyEdits } from "jsonc-parser";
 var logger = createLogger({ component: "setup-opencode" });
 function detectOpenCodeCli() {
@@ -1122,7 +515,7 @@ function detectOpenCodeCli() {
   }
 }
 function getOpenCodeConfigDir() {
-  return join6(homedir5(), ".config", "opencode");
+  return join4(homedir3(), ".config", "opencode");
 }
 function getNexusCommand() {
   return ["npx", "nexus-agents", "--mode=server"];
@@ -1133,12 +526,12 @@ var NEXUS_MCP_ENTRY = {
   enabled: true
 };
 function resolveOpenCodeConfig(dir) {
-  const jsoncPath = join6(dir, "opencode.jsonc");
-  if (existsSync4(jsoncPath)) {
+  const jsoncPath = join4(dir, "opencode.jsonc");
+  if (existsSync2(jsoncPath)) {
     return { path: jsoncPath, isJsonc: true, exists: true };
   }
-  const jsonPath = join6(dir, "opencode.json");
-  if (existsSync4(jsonPath)) {
+  const jsonPath = join4(dir, "opencode.json");
+  if (existsSync2(jsonPath)) {
     return { path: jsonPath, isJsonc: false, exists: true };
   }
   return { path: jsonPath, isJsonc: false, exists: false };
@@ -1146,7 +539,7 @@ function resolveOpenCodeConfig(dir) {
 function isAlreadyConfigured(resolved) {
   if (!resolved.exists) return false;
   try {
-    const raw = readFileSync4(resolved.path, "utf-8");
+    const raw = readFileSync3(resolved.path, "utf-8");
     const config = jsoncParse(raw);
     const mcp = config?.["mcp"];
     return mcp?.["nexus-agents"] !== void 0;
@@ -1169,9 +562,9 @@ function writeJsonConfig(configPath) {
   writeFileSync2(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 function writeOpenCodeConfig(configDir, resolved) {
-  if (!existsSync4(configDir)) mkdirSync3(configDir, { recursive: true });
+  if (!existsSync2(configDir)) mkdirSync2(configDir, { recursive: true });
   if (resolved.exists) {
-    const raw = readFileSync4(resolved.path, "utf-8");
+    const raw = readFileSync3(resolved.path, "utf-8");
     writeJsoncConfig(resolved.path, raw);
   } else {
     writeJsonConfig(resolved.path);
@@ -1179,7 +572,7 @@ function writeOpenCodeConfig(configDir, resolved) {
 }
 function validateProjectRoot(projectRoot) {
   const resolved = resolve(projectRoot);
-  if (!existsSync4(resolved)) {
+  if (!existsSync2(resolved)) {
     throw new Error(`Project root does not exist: ${resolved}`);
   }
   return resolved;
@@ -1188,7 +581,7 @@ function configureOpenCode(force, dryRun, options) {
   try {
     return configureOpenCodeInner(force, dryRun, options);
   } catch (error) {
-    const fallbackPath = join6(getOpenCodeConfigDir(), "opencode.json");
+    const fallbackPath = join4(getOpenCodeConfigDir(), "opencode.json");
     return {
       success: false,
       alreadyConfigured: false,
@@ -1226,10 +619,10 @@ function configureOpenCodeInner(force, dryRun, options) {
 }
 
 // src/cli/setup-gemini.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
 import { execFileSync as execFileSync3 } from "child_process";
-import { join as join7 } from "path";
-import { homedir as homedir6, platform as platform2 } from "os";
+import { join as join5 } from "path";
+import { homedir as homedir4, platform as platform2 } from "os";
 var logger2 = createLogger({ component: "setup-gemini" });
 function detectGeminiCli() {
   try {
@@ -1252,9 +645,9 @@ function detectGeminiCli() {
 }
 function getGeminiConfigDir(scope, projectRoot) {
   if (scope === "project" && projectRoot !== void 0) {
-    return join7(projectRoot, ".gemini");
+    return join5(projectRoot, ".gemini");
   }
-  return join7(homedir6(), ".gemini");
+  return join5(homedir4(), ".gemini");
 }
 function getNexusMcpEntry() {
   return {
@@ -1264,9 +657,9 @@ function getNexusMcpEntry() {
   };
 }
 function isAlreadyConfigured2(configPath) {
-  if (!existsSync5(configPath)) return false;
+  if (!existsSync3(configPath)) return false;
   try {
-    const config = JSON.parse(readFileSync5(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync4(configPath, "utf-8"));
     const servers = config["mcpServers"];
     return servers?.["nexus-agents"] !== void 0;
   } catch {
@@ -1275,15 +668,15 @@ function isAlreadyConfigured2(configPath) {
   }
 }
 function readExistingConfig(configPath) {
-  if (!existsSync5(configPath)) return {};
+  if (!existsSync3(configPath)) return {};
   try {
-    return JSON.parse(readFileSync5(configPath, "utf-8"));
+    return JSON.parse(readFileSync4(configPath, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeGeminiConfig(configDir, configPath) {
-  if (!existsSync5(configDir)) mkdirSync4(configDir, { recursive: true });
+  if (!existsSync3(configDir)) mkdirSync3(configDir, { recursive: true });
   const config = readExistingConfig(configPath);
   const servers = config["mcpServers"] ?? {};
   servers["nexus-agents"] = getNexusMcpEntry();
@@ -1292,7 +685,7 @@ function writeGeminiConfig(configDir, configPath) {
 }
 function configureGemini(force, dryRun, scope = "user", projectRoot) {
   const configDir = getGeminiConfigDir(scope, projectRoot);
-  const configPath = join7(configDir, "settings.json");
+  const configPath = join5(configDir, "settings.json");
   if (isAlreadyConfigured2(configPath) && !force) {
     return {
       success: true,
@@ -1442,7 +835,7 @@ function printOptions(options, defaultIndex) {
     const option = options[i];
     const marker = i === defaultIndex ? ">" : " ";
     const label = option?.label ?? "";
-    writeLine2(`  ${marker} ${String(i + 1)}. ${label}`);
+    writeLine(`  ${marker} ${String(i + 1)}. ${label}`);
   }
 }
 function getOptionValue(options, index, fallbackIndex) {
@@ -1454,7 +847,7 @@ function getOptionValue(options, index, fallbackIndex) {
   return fallback?.value ?? "";
 }
 async function promptSelect(rl, question, options, defaultIndex = 0) {
-  writeLine2("\n" + question);
+  writeLine("\n" + question);
   printOptions(options, defaultIndex);
   const answer = await promptInput(rl, `
 Choice [1-${String(options.length)}]: `);
@@ -1467,7 +860,7 @@ Choice [1-${String(options.length)}]: `);
   }
   return getOptionValue(options, defaultIndex, 0);
 }
-function writeLine2(text) {
+function writeLine(text) {
   process.stdout.write(text + "\n");
 }
 function writeEmptyLine() {
@@ -1475,21 +868,21 @@ function writeEmptyLine() {
 }
 function printWizardHeader() {
   writeEmptyLine();
-  writeLine2(formatHeader("Nexus Agents Setup Wizard"));
-  writeLine2("=".repeat(40));
-  writeLine2("This wizard will help you configure nexus-agents.");
+  writeLine(formatHeader("Nexus Agents Setup Wizard"));
+  writeLine("=".repeat(40));
+  writeLine("This wizard will help you configure nexus-agents.");
   writeEmptyLine();
 }
 function printStepProgress(state, stepName) {
-  writeLine2(
+  writeLine(
     `
 ${formatHeader(`Step ${String(state.currentStep)}/${String(state.totalSteps)}: ${stepName}`)}`
   );
-  writeLine2("-".repeat(40));
+  writeLine("-".repeat(40));
 }
 function printCompletion() {
   writeEmptyLine();
-  writeLine2(formatStatus("success") + " Wizard completed! Running setup...");
+  writeLine(formatStatus("success") + " Wizard completed! Running setup...");
   writeEmptyLine();
 }
 var USAGE_MODE_OPTIONS = [
@@ -1500,29 +893,29 @@ var USAGE_MODE_OPTIONS = [
 ];
 async function askUsageMode(rl, state) {
   printStepProgress(state, "Usage Mode");
-  writeLine2("How will you use nexus-agents?");
+  writeLine("How will you use nexus-agents?");
   const answer = await promptSelect(rl, "", USAGE_MODE_OPTIONS, 0);
   return answer;
 }
 async function askApiKeys(rl, state) {
   printStepProgress(state, "API Keys");
-  writeLine2("nexus-agents works best with API keys configured.");
-  writeLine2("Supported providers: Anthropic (Claude), OpenAI, Google (Gemini)");
+  writeLine("nexus-agents works best with API keys configured.");
+  writeLine("Supported providers: Anthropic (Claude), OpenAI, Google (Gemini)");
   writeEmptyLine();
   const hasKeys = await promptConfirm(rl, "Do you have at least one API key configured?", false);
   if (!hasKeys) {
     writeEmptyLine();
-    writeLine2("No worries! You can configure API keys later:");
-    writeLine2("  - ANTHROPIC_API_KEY for Claude");
-    writeLine2("  - OPENAI_API_KEY for OpenAI/Codex");
-    writeLine2("  - GOOGLE_AI_API_KEY for Gemini");
-    writeLine2("\nRun `nexus-agents doctor` to check your configuration.");
+    writeLine("No worries! You can configure API keys later:");
+    writeLine("  - ANTHROPIC_API_KEY for Claude");
+    writeLine("  - OPENAI_API_KEY for OpenAI/Codex");
+    writeLine("  - GOOGLE_AI_API_KEY for Gemini");
+    writeLine("\nRun `nexus-agents doctor` to check your configuration.");
   }
   return hasKeys;
 }
 async function askConfigDirectory(rl, state) {
   printStepProgress(state, "Configuration");
-  writeLine2("Where should nexus-agents store its configuration?");
+  writeLine("Where should nexus-agents store its configuration?");
   writeEmptyLine();
   const defaultDir = process.cwd();
   const answer = await promptInput(rl, `Directory [${defaultDir}]: `);
@@ -1530,33 +923,33 @@ async function askConfigDirectory(rl, state) {
 }
 async function askConfirmation(rl, state, answers) {
   printStepProgress(state, "Confirmation");
-  writeLine2("Setup will configure the following:");
+  writeLine("Setup will configure the following:");
   writeEmptyLine();
   const modeLabel = USAGE_MODE_OPTIONS.find((o) => o.value === answers.usageMode)?.label ?? "Unknown";
   const apiKeyStatus = answers.hasApiKeys === true ? "Configured" : "Not yet configured";
   const configDir = answers.configDirectory ?? process.cwd();
-  writeLine2(`  Usage mode: ${modeLabel}`);
-  writeLine2(`  API keys: ${apiKeyStatus}`);
-  writeLine2(`  Config directory: ${configDir}`);
+  writeLine(`  Usage mode: ${modeLabel}`);
+  writeLine(`  API keys: ${apiKeyStatus}`);
+  writeLine(`  Config directory: ${configDir}`);
   writeEmptyLine();
   const skipMcp = answers.usageMode === "standalone";
   if (!skipMcp) {
-    writeLine2("Will configure:");
-    writeLine2("  - MCP server for Claude integration");
-    writeLine2("  - Rules file (.claude/rules/nexus-agents.md)");
-    writeLine2("  - Hooks for session tracking");
+    writeLine("Will configure:");
+    writeLine("  - MCP server for Claude integration");
+    writeLine("  - Rules file (.claude/rules/nexus-agents.md)");
+    writeLine("  - Hooks for session tracking");
   } else {
-    writeLine2("Will configure:");
-    writeLine2("  - Rules file (.claude/rules/nexus-agents.md)");
-    writeLine2("  - (Skipping MCP/hooks - not needed for standalone mode)");
+    writeLine("Will configure:");
+    writeLine("  - Rules file (.claude/rules/nexus-agents.md)");
+    writeLine("  - (Skipping MCP/hooks - not needed for standalone mode)");
   }
   writeEmptyLine();
   return promptConfirm(rl, "Proceed with setup?", true);
 }
 async function runWizard() {
   if (!isInteractive()) {
-    writeLine2("Interactive mode not available (TTY required).");
-    writeLine2("Use --non-interactive flag for automated setup.");
+    writeLine("Interactive mode not available (TTY required).");
+    writeLine("Use --non-interactive flag for automated setup.");
     return void 0;
   }
   const rl = createReadline();
@@ -1577,7 +970,7 @@ async function runWizard() {
     state.currentStep++;
     if (!state.answers.confirmProceed) {
       writeEmptyLine();
-      writeLine2("Setup cancelled.");
+      writeLine("Setup cancelled.");
       return void 0;
     }
     printCompletion();
@@ -1604,94 +997,94 @@ function convertAnswersToOptions(answers) {
 }
 
 // src/cli/setup-command.ts
-function writeLine3(text) {
+function writeLine2(text) {
   process.stdout.write(text + "\n");
 }
 function writeEmptyLine2() {
   process.stdout.write("\n");
 }
 function printMcpResult(mcpResult, snippet) {
-  writeLine3(formatHeader("MCP Configuration"));
-  writeLine3("\u2500".repeat(40));
+  writeLine2(formatHeader("MCP Configuration"));
+  writeLine2("\u2500".repeat(40));
   if (mcpResult.success) {
-    writeLine3(mcpResult.message);
-    writeLine3("Run `/mcp` in Claude Code to verify.");
+    writeLine2(mcpResult.message);
+    writeLine2("Run `/mcp` in Claude Code to verify.");
   } else {
-    writeLine3(`Failed: ${mcpResult.message}`);
+    writeLine2(`Failed: ${mcpResult.message}`);
     if (snippet !== void 0) {
       writeEmptyLine2();
-      writeLine3("Manual fallback - run:");
+      writeLine2("Manual fallback - run:");
       writeEmptyLine2();
-      writeLine3(formatCodeBlock(`claude mcp add-json nexus-agents '${snippet}'`));
+      writeLine2(formatCodeBlock(`claude mcp add-json nexus-agents '${snippet}'`));
     }
   }
   writeEmptyLine2();
 }
 function printRulesFile(rulesPath) {
-  writeLine3(formatHeader("Rules File"));
-  writeLine3("\u2500".repeat(40));
-  writeLine3(`Created: ${rulesPath}`);
-  writeLine3("Claude will now have context about nexus-agents tools.");
+  writeLine2(formatHeader("Rules File"));
+  writeLine2("\u2500".repeat(40));
+  writeLine2(`Created: ${rulesPath}`);
+  writeLine2("Claude will now have context about nexus-agents tools.");
   writeEmptyLine2();
 }
 function printHooksResult(hookResult, snippet) {
-  writeLine3(formatHeader("Hooks Configuration"));
-  writeLine3("\u2500".repeat(40));
+  writeLine2(formatHeader("Hooks Configuration"));
+  writeLine2("\u2500".repeat(40));
   if (hookResult.success) {
-    writeLine3(hookResult.message);
-    writeLine3("Hooks will track sessions, metrics, and validate tool use.");
+    writeLine2(hookResult.message);
+    writeLine2("Hooks will track sessions, metrics, and validate tool use.");
   } else {
-    writeLine3(`Note: ${hookResult.message}`);
+    writeLine2(`Note: ${hookResult.message}`);
     if (snippet !== void 0) {
       writeEmptyLine2();
-      writeLine3("Manual fallback - add to ~/.claude/settings.json:");
+      writeLine2("Manual fallback - add to ~/.claude/settings.json:");
       writeEmptyLine2();
-      writeLine3(formatCodeBlock(snippet));
+      writeLine2(formatCodeBlock(snippet));
     }
   }
   writeEmptyLine2();
 }
 function printWarnings(warnings) {
-  writeLine3(formatHeader("Warnings"));
-  writeLine3("\u2500".repeat(40));
+  writeLine2(formatHeader("Warnings"));
+  writeLine2("\u2500".repeat(40));
   for (const warning of warnings) {
-    writeLine3(`\u26A0 ${warning}`);
+    writeLine2(`\u26A0 ${warning}`);
   }
   writeEmptyLine2();
 }
 function printErrors(errors) {
-  writeLine3(formatHeader("Errors"));
-  writeLine3("\u2500".repeat(40));
+  writeLine2(formatHeader("Errors"));
+  writeLine2("\u2500".repeat(40));
   for (const error of errors) {
-    writeLine3(`\u2717 ${error}`);
+    writeLine2(`\u2717 ${error}`);
   }
   writeEmptyLine2();
 }
 function printNextSteps(mcpConfigured, hasMcpSnippet) {
-  writeLine3(formatHeader("Next Steps"));
-  writeLine3("\u2500".repeat(40));
+  writeLine2(formatHeader("Next Steps"));
+  writeLine2("\u2500".repeat(40));
   if (hasMcpSnippet && !mcpConfigured) {
-    writeLine3("1. Configure MCP manually (see above)");
-    writeLine3("2. Restart Claude Code");
+    writeLine2("1. Configure MCP manually (see above)");
+    writeLine2("2. Restart Claude Code");
   }
-  writeLine3("3. Run: nexus-agents doctor");
-  writeLine3('4. Try: nexus-agents orchestrate "Hello World"');
+  writeLine2("3. Run: nexus-agents doctor");
+  writeLine2('4. Try: nexus-agents orchestrate "Hello World"');
   writeEmptyLine2();
 }
 function printSteps(steps, verbose) {
   for (const step of steps) {
     const status = formatStatus(step.status);
     const duration = step.durationMs !== void 0 ? ` (${String(step.durationMs)}ms)` : "";
-    writeLine3(`${status} ${step.name}${verbose ? duration : ""}`);
+    writeLine2(`${status} ${step.name}${verbose ? duration : ""}`);
     if (step.message !== void 0 && (verbose || step.status === "failed")) {
-      writeLine3(`  ${step.message}`);
+      writeLine2(`  ${step.message}`);
     }
   }
   writeEmptyLine2();
 }
 function printSummary(success) {
   const summary = success ? "\u2713 Setup completed successfully!" : "\u2717 Setup completed with errors";
-  writeLine3(success ? `\x1B[32m${summary}\x1B[0m` : `\x1B[31m${summary}\x1B[0m`);
+  writeLine2(success ? `\x1B[32m${summary}\x1B[0m` : `\x1B[31m${summary}\x1B[0m`);
   writeEmptyLine2();
 }
 function runDetectionStep(projectRoot) {
@@ -1708,6 +1101,31 @@ function runDetectionStep(projectRoot) {
     }
   };
 }
+var REQUIRED_NODE_MAJOR = 22;
+function runPrerequisiteStep() {
+  const time = getTimeProvider();
+  const startTime = time.now();
+  const warnings = [];
+  const version = process.version;
+  const major = Number(version.slice(1).split(".")[0]);
+  const nodeOk = major >= REQUIRED_NODE_MAJOR;
+  if (!nodeOk) {
+    warnings.push(
+      `Node.js ${version} detected \u2014 v${String(REQUIRED_NODE_MAJOR)}.x+ required. Some features may not work.`
+    );
+  }
+  const status = nodeOk ? "success" : "warning";
+  const message = nodeOk ? `Node.js ${version} (meets v${String(REQUIRED_NODE_MAJOR)}.x requirement)` : `Node.js ${version} \u2014 v${String(REQUIRED_NODE_MAJOR)}.x+ required`;
+  return {
+    step: {
+      name: "Prerequisite Check",
+      status,
+      message,
+      durationMs: time.now() - startTime
+    },
+    warnings
+  };
+}
 function makeMcpResult(status, message, startTime, snippet, mcpResult) {
   return {
     step: {
@@ -1775,7 +1193,7 @@ function runRulesStep(env, options) {
     return makeRulesResult("skipped", "Skipped (--skip-rules)", startTime);
   }
   const rulesPath = getRulesFilePath(env.projectInfo.root);
-  if (existsSync6(rulesPath) && !options.force) {
+  if (existsSync4(rulesPath) && !options.force) {
     return makeRulesResult(
       "skipped",
       "Rules file already exists (use --force to overwrite)",
@@ -1994,6 +1412,8 @@ function runSetup(options = {}) {
   const warnings = [];
   const { env, step: detectionStep } = runDetectionStep(projectRoot);
   addClaudeCliWarnings(warnings, env.claudeCli.installed);
+  const { step: prereqStep, warnings: prereqWarnings } = runPrerequisiteStep();
+  warnings.push(...prereqWarnings);
   const { step: mcpStep, snippet, mcpResult } = runMcpConfigStep(env, parsedOptions);
   const { step: rulesStep, rulesPath } = runRulesStep(env, parsedOptions);
   const { step: hooksStep, hookSnippet, hookResult } = runHooksStep(env, parsedOptions);
@@ -2004,6 +1424,7 @@ function runSetup(options = {}) {
   const configStep = runConfigStep(projectRoot, parsedOptions);
   const steps = [
     detectionStep,
+    prereqStep,
     mcpStep,
     rulesStep,
     hooksStep,
@@ -2047,17 +1468,17 @@ function printDetailSections(result) {
   if (result.dataDirPath !== void 0) printDataDirSection(result);
 }
 function printDataDirSection(result) {
-  writeLine3(formatHeader("Data Directory"));
-  writeLine3("\u2500".repeat(40));
+  writeLine2(formatHeader("Data Directory"));
+  writeLine2("\u2500".repeat(40));
   const count = result.dataDirsCreated ?? 0;
   const msg = count > 0 ? `Created ${String(count)} directories under ${result.dataDirPath ?? ""}` : `All directories already exist at ${result.dataDirPath ?? ""}`;
-  writeLine3(msg);
+  writeLine2(msg);
   writeEmptyLine2();
 }
 function printSetupResult(result, verbose) {
   writeEmptyLine2();
-  writeLine3(formatHeader(`Nexus Agents Setup v${VERSION}`));
-  writeLine3("\u2550".repeat(40));
+  writeLine2(formatHeader(`Nexus Agents Setup v${VERSION}`));
+  writeLine2("\u2550".repeat(40));
   writeEmptyLine2();
   printSteps(result.steps, verbose);
   printDetailSections(result);
@@ -2069,8 +1490,8 @@ function printSetupResult(result, verbose) {
 function setupCommand(options = {}) {
   const parsedOptions = SetupOptionsSchema.parse(options);
   if (!isInteractive() && !parsedOptions.nonInteractive) {
-    writeLine3("Non-interactive environment detected.");
-    writeLine3("Run with --non-interactive or set CI=true.");
+    writeLine2("Non-interactive environment detected.");
+    writeLine2("Run with --non-interactive or set CI=true.");
     return 1;
   }
   const result = runSetup(options);
@@ -2100,7 +1521,6 @@ export {
   runSetup,
   printSetupResult,
   setupCommand,
-  setupCommandAsync,
-  doctorCommand
+  setupCommandAsync
 };
-//# sourceMappingURL=chunk-UVQ7R4C4.js.map
+//# sourceMappingURL=chunk-YSDUVCCZ.js.map