nexus-agents 2.55.0 → 2.56.0

package/dist/{chunk-JEKPVSC4.js → chunk-KGMC6F5D.js}

@@ -3,16 +3,25 @@ import {
 } from "./chunk-EKYT4NMD.js";
 import {
   VERSION,
+  checkApiKeys,
+  checkDataDirectory,
+  checkSqlite,
+  defaultConfig,
   initDataDirectories
-} from "./chunk-SY344FS5.js";
+} from "./chunk-C3FGEDD7.js";
+import {
+  BUILT_IN_EXPERTS
+} from "./chunk-GJVHRJO2.js";
 import {
   CLI_SUBPROCESS_TIMEOUTS,
+  colors,
   createLogger,
   formatCodeBlock,
   formatHeader,
   formatStatus,
   getErrorMessage,
-  getTimeProvider
+  getTimeProvider,
+  symbols
 } from "./chunk-UOUJZIKH.js";
 
 // src/cli/setup-command.ts
@@ -1050,6 +1059,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");
@@ -1547,6 +1815,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 +1880,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);
+  }
+  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 };
   }
-  return setupCommand(options);
+  const result = runSetup(options);
+  printSetupResult(result, parsedOptions.verbose);
+  return { exitCode: result.success ? 0 : 1, mcpConfigured: result.mcpConfigured === true };
 }
 
 export {
@@ -1578,9 +1921,10 @@ export {
   generateMcpSnippet,
   generateRulesContent,
   runWizard,
+  verifyCommand,
   runSetup,
   printSetupResult,
   setupCommand,
   setupCommandAsync
 };
-//# sourceMappingURL=chunk-JEKPVSC4.js.map
+//# sourceMappingURL=chunk-KGMC6F5D.js.map