nexus-agents 2.55.1 → 2.57.0

package/dist/{chunk-XYCS5X3H.js → chunk-QNYNQ257.js}

@@ -1,19 +1,28 @@
 import {
   runConfigInitSync
-} from "./chunk-EKYT4NMD.js";
+} from "./chunk-QGZBCD2A.js";
 import {
   VERSION,
+  checkApiKeys,
+  checkDataDirectory,
+  checkSqlite,
+  defaultConfig,
   initDataDirectories
-} from "./chunk-OC7RMLN2.js";
+} from "./chunk-Y7CD6AZW.js";
+import {
+  BUILT_IN_EXPERTS
+} from "./chunk-GJVHRJO2.js";
 import {
   CLI_SUBPROCESS_TIMEOUTS,
+  colors,
   createLogger,
   formatCodeBlock,
   formatHeader,
   formatStatus,
   getErrorMessage,
-  getTimeProvider
-} from "./chunk-UOUJZIKH.js";
+  getTimeProvider,
+  symbols
+} from "./chunk-R2Y57PM3.js";
 
 // src/cli/setup-command.ts
 import { existsSync as existsSync4 } from "fs";
@@ -493,30 +502,70 @@ function isInteractive() {
 
 // src/cli/setup-opencode.ts
 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 join4, resolve } from "path";
-import { homedir as homedir3, platform } from "os";
+import { homedir as homedir3 } from "os";
 import { parse as jsoncParse, modify, applyEdits } from "jsonc-parser";
-var logger = createLogger({ component: "setup-opencode" });
-function detectOpenCodeCli() {
+
+// src/cli/setup-cli-detection.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { platform } from "os";
+
+// src/cli/cli-detection-error.ts
+var DETECTION_ERROR_MESSAGES = {
+  "not-found": "binary not on PATH",
+  timeout: "detection timed out (hung PATH?)",
+  permission: "binary present but not executable",
+  other: "detection failed \u2014 check verbose logs"
+};
+function formatDetectionMessage(cliName, detectionError) {
+  if (detectionError === void 0 || detectionError === "not-found") {
+    return `${cliName} not installed`;
+  }
+  return `${cliName} detection failed: ${DETECTION_ERROR_MESSAGES[detectionError]}`;
+}
+function classifyExecError(err) {
+  if (typeof err !== "object" || err === null) return "other";
+  const e = err;
+  if (e.code === "ENOENT") return "not-found";
+  if (e.code === "ETIMEDOUT") return "timeout";
+  if (e.killed === true || e.signal === "SIGTERM" || e.signal === "SIGKILL") {
+    return "timeout";
+  }
+  if (e.code === "EACCES" || e.code === "EPERM") return "permission";
+  return "other";
+}
+
+// src/cli/setup-cli-detection.ts
+function getCliLocatorCommand() {
+  return platform() === "win32" ? "where" : "which";
+}
+function extractSemver(output) {
+  const match = /(\d+\.\d+\.\d+)/.exec(output);
+  return match?.[1];
+}
+function detectCliBinary(name) {
   try {
-    const cmd = platform() === "win32" ? "where" : "which";
-    execFileSync2(cmd, ["opencode"], { timeout: 3e3, stdio: "pipe" });
-  } catch {
-    return { installed: false, version: void 0 };
+    execFileSync2(getCliLocatorCommand(), [name], { timeout: 3e3, stdio: "pipe" });
+  } catch (err) {
+    return { installed: false, version: void 0, detectionError: classifyExecError(err) };
   }
   try {
-    const output = execFileSync2("opencode", ["--version"], {
+    const output = execFileSync2(name, ["--version"], {
       timeout: 5e3,
       stdio: "pipe",
       encoding: "utf-8"
     });
-    const match = /(\d+\.\d+\.\d+)/.exec(output);
-    return { installed: true, version: match?.[1] };
-  } catch {
-    return { installed: true, version: void 0 };
+    return { installed: true, version: extractSemver(output) };
+  } catch (err) {
+    return { installed: true, version: void 0, detectionError: classifyExecError(err) };
   }
 }
+
+// src/cli/setup-opencode.ts
+var logger = createLogger({ component: "setup-opencode" });
+function detectOpenCodeCli() {
+  return detectCliBinary("opencode");
+}
 function getOpenCodeConfigDir() {
   return join4(homedir3(), ".config", "opencode");
 }
@@ -623,28 +672,11 @@ function configureOpenCodeInner(force, dryRun, options) {
 
 // src/cli/setup-gemini.ts
 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 join5 } from "path";
-import { homedir as homedir4, platform as platform2 } from "os";
+import { homedir as homedir4 } from "os";
 var logger2 = createLogger({ component: "setup-gemini" });
 function detectGeminiCli() {
-  try {
-    const cmd = platform2() === "win32" ? "where" : "which";
-    execFileSync3(cmd, ["gemini"], { timeout: 3e3, stdio: "pipe" });
-  } catch {
-    return { installed: false, version: void 0 };
-  }
-  try {
-    const output = execFileSync3("gemini", ["--version"], {
-      timeout: 5e3,
-      stdio: "pipe",
-      encoding: "utf-8"
-    });
-    const match = /(\d+\.\d+\.\d+)/.exec(output);
-    return { installed: true, version: match?.[1] };
-  } catch {
-    return { installed: true, version: void 0 };
-  }
+  return detectCliBinary("gemini");
 }
 function getGeminiConfigDir(scope, projectRoot) {
   if (scope === "project" && projectRoot !== void 0) {
@@ -724,31 +756,14 @@ function configureGemini(force, dryRun, scope = "user", projectRoot) {
 }
 
 // src/cli/setup-codex.ts
-import { execFileSync as execFileSync4 } from "child_process";
-import { platform as platform3 } from "os";
+import { execFileSync as execFileSync3 } from "child_process";
 var logger3 = createLogger({ component: "setup-codex" });
 function detectCodexCli() {
-  try {
-    const cmd = platform3() === "win32" ? "where" : "which";
-    execFileSync4(cmd, ["codex"], { timeout: 3e3, stdio: "pipe" });
-  } catch {
-    return { installed: false, version: void 0 };
-  }
-  try {
-    const output = execFileSync4("codex", ["--version"], {
-      timeout: 5e3,
-      stdio: "pipe",
-      encoding: "utf-8"
-    });
-    const match = /(\d+\.\d+\.\d+)/.exec(output);
-    return { installed: true, version: match?.[1] };
-  } catch {
-    return { installed: true, version: void 0 };
-  }
+  return detectCliBinary("codex");
 }
 function isAlreadyConfigured3() {
   try {
-    const output = execFileSync4("codex", ["mcp", "list"], {
+    const output = execFileSync3("codex", ["mcp", "list"], {
       timeout: 5e3,
       stdio: "pipe",
       encoding: "utf-8"
@@ -760,7 +775,7 @@ function isAlreadyConfigured3() {
 }
 function removeExisting() {
   try {
-    execFileSync4("codex", ["mcp", "remove", "nexus-agents"], {
+    execFileSync3("codex", ["mcp", "remove", "nexus-agents"], {
       timeout: 5e3,
       stdio: "pipe"
     });
@@ -770,7 +785,7 @@ function removeExisting() {
 }
 function addMcpServer2() {
   try {
-    execFileSync4(
+    execFileSync3(
       "codex",
       ["mcp", "add", "nexus-agents", "--", "npx", "nexus-agents", "--mode=server"],
       {
@@ -1050,6 +1065,265 @@ function buildPermissionsBanner(snippet) {
   ].join("\n");
 }
 
+// src/cli/verify-command.ts
+function checkNodeVersion() {
+  const version = process.version;
+  const major = parseInt(version.slice(1).split(".")[0] ?? "0", 10);
+  if (major >= 22) {
+    return {
+      name: "Node.js Version",
+      passed: true,
+      message: `${version} (LTS)`
+    };
+  }
+  if (major >= 18) {
+    return {
+      name: "Node.js Version",
+      passed: true,
+      message: `${version} (supported, recommend 22.x LTS)`
+    };
+  }
+  return {
+    name: "Node.js Version",
+    passed: false,
+    message: `${version} (unsupported)`,
+    fix: "Install Node.js 22.x LTS from https://nodejs.org"
+  };
+}
+function checkPackageExports() {
+  try {
+    const hasVersion = typeof VERSION === "string" && VERSION.length > 0;
+    const hasConfig = typeof defaultConfig === "object";
+    const hasBuiltInExperts = typeof BUILT_IN_EXPERTS === "object";
+    if (hasVersion && hasConfig && hasBuiltInExperts) {
+      return {
+        name: "Package Exports",
+        passed: true,
+        message: "All core modules accessible"
+      };
+    }
+    return {
+      name: "Package Exports",
+      passed: false,
+      message: "Some modules failed to load",
+      fix: "Try reinstalling: npm install -g nexus-agents"
+    };
+  } catch {
+    return {
+      name: "Package Exports",
+      passed: false,
+      message: "Failed to load core modules",
+      fix: "Try reinstalling: npm install -g nexus-agents"
+    };
+  }
+}
+function checkConfigLoading() {
+  try {
+    const hasModels = typeof defaultConfig.models === "object";
+    const hasSecurity = typeof defaultConfig.security === "object";
+    if (hasModels && hasSecurity) {
+      return {
+        name: "Configuration",
+        passed: true,
+        message: "Default config accessible"
+      };
+    }
+    return {
+      name: "Configuration",
+      passed: true,
+      // Config errors are not fatal for verification
+      message: "Using default configuration"
+    };
+  } catch {
+    return {
+      name: "Configuration",
+      passed: true,
+      // Still works with defaults
+      message: "Using default configuration"
+    };
+  }
+}
+function checkExpertSystem() {
+  const expertTypes = Object.keys(BUILT_IN_EXPERTS);
+  const count = expertTypes.length;
+  if (count >= 5) {
+    return {
+      name: "Expert System",
+      passed: true,
+      message: `${String(count)} expert types available`
+    };
+  }
+  return {
+    name: "Expert System",
+    passed: false,
+    message: "Expert types not loaded",
+    fix: "Try reinstalling: npm install -g nexus-agents"
+  };
+}
+async function checkSqliteAvailability() {
+  const result = await checkSqlite();
+  if (result.available) {
+    return {
+      name: "SQLite Storage",
+      passed: true,
+      message: "better-sqlite3 loaded (memory backends available)"
+    };
+  }
+  return {
+    name: "SQLite Storage",
+    passed: false,
+    severity: "warn",
+    message: result.error ?? "better-sqlite3 not available",
+    fix: 'Run "pnpm rebuild better-sqlite3" or reinstall nexus-agents'
+  };
+}
+function checkDataDirs() {
+  const result = checkDataDirectory();
+  const unwritable = result.subdirectories.filter((s) => !s.exists || !s.writable);
+  if (result.rootExists && unwritable.length === 0) {
+    return {
+      name: "Data Directories",
+      passed: true,
+      message: `${result.rootPath} (all subdirectories writable)`
+    };
+  }
+  if (!result.rootExists) {
+    return {
+      name: "Data Directories",
+      passed: false,
+      severity: "warn",
+      message: `${result.rootPath} does not exist`,
+      fix: "Run any nexus-agents command \u2014 directories auto-initialize on first run"
+    };
+  }
+  return {
+    name: "Data Directories",
+    passed: false,
+    severity: "warn",
+    message: `${String(unwritable.length)} subdirectory(ies) unwritable: ${unwritable.map((s) => s.name).join(", ")}`,
+    fix: `Check filesystem permissions on ${result.rootPath}`
+  };
+}
+function checkAdapterAvailability() {
+  const keys = checkApiKeys();
+  const configured = keys.filter((k) => k.configured);
+  if (configured.length > 0) {
+    return {
+      name: "Adapter Availability",
+      passed: true,
+      message: `${String(configured.length)} API key(s) configured: ${configured.map((k) => k.name).join(", ")}`
+    };
+  }
+  return {
+    name: "Adapter Availability",
+    passed: false,
+    severity: "warn",
+    message: "No API keys configured (ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_AI_API_KEY)",
+    fix: 'Set at least one API key, or install a CLI (claude/gemini/codex/opencode) and run "nexus-agents doctor"'
+  };
+}
+async function runVerify() {
+  const time = getTimeProvider();
+  const startTime = time.now();
+  const checks = [
+    checkNodeVersion(),
+    checkPackageExports(),
+    checkConfigLoading(),
+    checkExpertSystem(),
+    await checkSqliteAvailability(),
+    checkDataDirs(),
+    checkAdapterAvailability()
+  ];
+  const allPassed = checks.every((c) => c.passed);
+  const noHardFailures = checks.every((c) => c.passed || c.severity === "warn");
+  const durationMs = time.now() - startTime;
+  return {
+    version: VERSION,
+    nodeVersion: process.version,
+    checks,
+    allPassed,
+    noHardFailures,
+    durationMs
+  };
+}
+function formatCheck(check) {
+  let symbol;
+  if (check.passed) {
+    symbol = `${colors.green}${symbols.check}${colors.reset}`;
+  } else if (check.severity === "warn") {
+    symbol = `${colors.yellow}${symbols.warn}${colors.reset}`;
+  } else {
+    symbol = `${colors.red}${symbols.cross}${colors.reset}`;
+  }
+  let line = `  ${symbol} ${check.name}: ${check.message}`;
+  if (!check.passed && check.fix !== void 0) {
+    line += `
+     ${colors.dim}Fix: ${check.fix}${colors.reset}`;
+  }
+  return line;
+}
+function printVerifyResult(result, verbose) {
+  process.stdout.write("\n");
+  process.stdout.write(`${colors.bold}nexus-agents verify${colors.reset}
+`);
+  process.stdout.write("===================\n");
+  process.stdout.write("\n");
+  process.stdout.write(`Version: ${result.version}
+`);
+  process.stdout.write(`Node.js: ${result.nodeVersion}
+`);
+  process.stdout.write("\n");
+  process.stdout.write(`${colors.cyan}Running checks...${colors.reset}
+`);
+  process.stdout.write("\n");
+  for (const check of result.checks) {
+    process.stdout.write(formatCheck(check) + "\n");
+  }
+  process.stdout.write("\n");
+  const warnCount = result.checks.filter((c) => !c.passed && c.severity === "warn").length;
+  const hardCount = result.checks.filter((c) => !c.passed && c.severity !== "warn").length;
+  if (result.allPassed) {
+    process.stdout.write(
+      `${colors.green}${colors.bold}Installation verified successfully!${colors.reset}
+`
+    );
+    process.stdout.write("\n");
+    process.stdout.write(`${colors.cyan}Next steps:${colors.reset}
+`);
+    process.stdout.write('  1. Run "nexus-agents doctor" to check external CLI integrations\n');
+    process.stdout.write(
+      '  2. Run "nexus-agents review --setup" to configure GitHub integration\n'
+    );
+    process.stdout.write('  3. Try "nexus-agents --help" for all available commands\n');
+  } else if (hardCount === 0) {
+    process.stdout.write(
+      `${colors.yellow}${colors.bold}Verified with ${String(warnCount)} warning(s) \u2014 functional but degraded${colors.reset}
+`
+    );
+    process.stdout.write("\n");
+    process.stdout.write("The warnings above indicate reduced functionality but will not\n");
+    process.stdout.write("prevent nexus-agents from running. Fix them when convenient.\n");
+  } else {
+    process.stdout.write(
+      `${colors.red}${colors.bold}Verification failed: ${String(hardCount)} blocking issue(s), ${String(warnCount)} warning(s)${colors.reset}
+`
+    );
+    process.stdout.write("\n");
+    process.stdout.write("Please fix the blocking issues above and try again.\n");
+  }
+  process.stdout.write("\n");
+  if (verbose) {
+    process.stdout.write(`${colors.dim}Duration: ${String(result.durationMs)}ms${colors.reset}
+`);
+    process.stdout.write("\n");
+  }
+}
+async function verifyCommand(options) {
+  const result = await runVerify();
+  printVerifyResult(result, options.verbose);
+  return result.noHardFailures ? 0 : 1;
+}
+
 // src/cli/setup-command.ts
 function writeLine2(text) {
   process.stdout.write(text + "\n");
@@ -1306,7 +1580,7 @@ function runOpenCodeStep(options) {
     return {
       name: "OpenCode MCP",
       status: "skipped",
-      message: "OpenCode CLI not installed",
+      message: formatDetectionMessage("OpenCode CLI", cliInfo.detectionError),
       durationMs: getTimeProvider().now() - startTime
     };
   }
@@ -1333,7 +1607,7 @@ function runGeminiStep(options) {
     return {
       name: "Gemini MCP",
       status: "skipped",
-      message: "Gemini CLI not installed",
+      message: formatDetectionMessage("Gemini CLI", cliInfo.detectionError),
       durationMs: getTimeProvider().now() - startTime
     };
   }
@@ -1373,7 +1647,7 @@ function runCodexStep(options) {
     return {
       name: "Codex MCP",
       status: "skipped",
-      message: "Codex CLI not installed",
+      message: formatDetectionMessage("Codex CLI", cliInfo.detectionError),
       durationMs: getTimeProvider().now() - startTime
     };
   }
@@ -1547,6 +1821,60 @@ function printSetupResult(result, verbose) {
   printNextSteps(result.mcpConfigured === true, result.mcpSnippet !== void 0);
   printSummary(result.success);
 }
+function printGettingStartedBanner(mcpConfigured) {
+  writeEmptyLine2();
+  writeLine2(formatHeader("Getting started"));
+  writeLine2("\u2500".repeat(40));
+  writeLine2("  1. nexus-agents hello             \u2014 guided tour (no API keys needed)");
+  if (mcpConfigured) {
+    writeLine2("  2. Use through Claude Code        \u2014 type /mcp in Claude to list tools");
+  } else {
+    writeLine2('  2. nexus-agents orchestrate "..."  \u2014 run your first task');
+  }
+  writeLine2("  3. nexus-agents workflow list     \u2014 explore built-in workflows");
+  writeEmptyLine2();
+  writeLine2(`  ${colors.dim}Docs: https://github.com/williamzujkowski/nexus-agents${colors.reset}`);
+  writeLine2(`  ${colors.dim}Harness wiring: docs/guides/HARNESS_COMPATIBILITY.md${colors.reset}`);
+}
+async function runPostSetupHealthGate(dryRun) {
+  if (dryRun) return true;
+  const result = await runVerify();
+  const passed = result.checks.filter((c) => c.passed).length;
+  const total = result.checks.length;
+  writeEmptyLine2();
+  writeLine2(formatHeader(`Health check (${String(passed)}/${String(total)} passed)`));
+  writeLine2("\u2500".repeat(40));
+  for (const check of result.checks) {
+    let symbol;
+    if (check.passed) {
+      symbol = `${colors.green}${symbols.check}${colors.reset}`;
+    } else if (check.severity === "warn") {
+      symbol = `${colors.yellow}${symbols.warn}${colors.reset}`;
+    } else {
+      symbol = `${colors.red}${symbols.cross}${colors.reset}`;
+    }
+    writeLine2(`  ${symbol} ${check.name}: ${check.message}`);
+    if (!check.passed && check.fix !== void 0) {
+      writeLine2(`     ${colors.dim}\u2192 Fix: ${check.fix}${colors.reset}`);
+    }
+  }
+  writeEmptyLine2();
+  if (!result.noHardFailures) {
+    writeLine2(
+      `${colors.red}${colors.bold}Action required: fix the blocking issues above before using nexus-agents.${colors.reset}`
+    );
+  } else if (!result.allPassed) {
+    const warnCount = result.checks.filter((c) => !c.passed).length;
+    writeLine2(
+      `${colors.yellow}${colors.bold}Setup complete with ${String(warnCount)} warning(s) \u2014 nexus-agents will run but some features are degraded.${colors.reset}`
+    );
+  } else {
+    writeLine2(
+      `${colors.green}${colors.bold}All health checks passed. nexus-agents is ready.${colors.reset}`
+    );
+  }
+  return result.noHardFailures;
+}
 function setupCommand(options = {}) {
   const parsedOptions = SetupOptionsSchema.parse(options);
   if (!isInteractive() && !parsedOptions.nonInteractive) {
@@ -1558,19 +1886,40 @@ function setupCommand(options = {}) {
   printSetupResult(result, parsedOptions.verbose);
   return result.success ? 0 : 1;
 }
+async function runInteractiveSetup(options) {
+  const wizardOptions = await runWizard();
+  if (wizardOptions === void 0) return 1;
+  const mergedOptions = { ...options, ...wizardOptions };
+  delete mergedOptions.interactive;
+  const result = runSetup(mergedOptions);
+  printSetupResult(result, mergedOptions.verbose ?? false);
+  const healthOk = await runPostSetupHealthGate(mergedOptions.dryRun ?? false);
+  if (result.success && !(mergedOptions.dryRun ?? false)) {
+    printGettingStartedBanner(result.mcpConfigured === true);
+  }
+  return result.success && healthOk ? 0 : 1;
+}
 async function setupCommandAsync(options = {}) {
   if (options.interactive === true) {
-    const wizardOptions = await runWizard();
-    if (wizardOptions === void 0) {
-      return 1;
-    }
-    const mergedOptions = { ...options, ...wizardOptions };
-    delete mergedOptions.interactive;
-    const result = runSetup(mergedOptions);
-    printSetupResult(result, mergedOptions.verbose ?? false);
-    return result.success ? 0 : 1;
+    return runInteractiveSetup(options);
   }
-  return setupCommand(options);
+  const setupResult = runSetupAndPrint(options);
+  const healthOk = await runPostSetupHealthGate(options.dryRun ?? false);
+  if (setupResult.exitCode === 0 && !(options.dryRun ?? false)) {
+    printGettingStartedBanner(setupResult.mcpConfigured);
+  }
+  return setupResult.exitCode !== 0 || !healthOk ? 1 : 0;
+}
+function runSetupAndPrint(options) {
+  const parsedOptions = SetupOptionsSchema.parse(options);
+  if (!isInteractive() && !parsedOptions.nonInteractive) {
+    writeLine2("Non-interactive environment detected.");
+    writeLine2("Run with --non-interactive or set CI=true.");
+    return { exitCode: 1, mcpConfigured: false };
+  }
+  const result = runSetup(options);
+  printSetupResult(result, parsedOptions.verbose);
+  return { exitCode: result.success ? 0 : 1, mcpConfigured: result.mcpConfigured === true };
 }
 
 export {
@@ -1578,9 +1927,10 @@ export {
   generateMcpSnippet,
   generateRulesContent,
   runWizard,
+  verifyCommand,
   runSetup,
   printSetupResult,
   setupCommand,
   setupCommandAsync
 };
-//# sourceMappingURL=chunk-XYCS5X3H.js.map
+//# sourceMappingURL=chunk-QNYNQ257.js.map