nexus-agents 2.28.0 → 2.29.0

package/dist/chunk-5VZLXMO7.js

@@ -0,0 +1,838 @@
+import {
+  capitalize
+} from "./chunk-633WH2ML.js";
+import {
+  createAllAdapters
+} from "./chunk-ZBZJHXRT.js";
+import {
+  DEFAULT_CAPABILITIES,
+  DEFAULT_MODEL_CAPABILITIES,
+  colors,
+  createLogger,
+  err,
+  getErrorMessage,
+  getTimeProvider,
+  ok,
+  symbols,
+  writeLine
+} from "./chunk-IMWYKX4H.js";
+import {
+  LEARNING_DIR,
+  OUTCOMES_FILE,
+  RULES_FILE,
+  isPersistenceEnabled
+} from "./chunk-CLYZ7FWP.js";
+
+// src/version.ts
+var VERSION = true ? "2.29.0" : "dev";
+
+// src/cli/setup-data-dir.ts
+import { mkdirSync, existsSync as existsSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+
+// src/cli/doctor.ts
+import { existsSync, readFileSync, accessSync, constants as fsConstants } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/mcp/task-store.ts
+import { InMemoryTaskStore } from "@modelcontextprotocol/sdk/experimental/tasks";
+var MAX_TASK_TTL_MS = 6e5;
+var DEFAULT_TASK_TTL_MS = 3e5;
+var MAX_TASK_CAPACITY = 50;
+var CLEANUP_INTERVAL_MS = 6e4;
+var logger = createLogger({ component: "task-store" });
+var singletonStore;
+var cleanupTimer;
+function getTaskStore() {
+  if (singletonStore === void 0) {
+    singletonStore = new InMemoryTaskStore();
+    logger.info("Task store created", { maxCapacity: MAX_TASK_CAPACITY });
+    cleanupTimer = setInterval(() => {
+      evictExcessTasks();
+    }, CLEANUP_INTERVAL_MS);
+    if (typeof cleanupTimer === "object" && "unref" in cleanupTimer) {
+      cleanupTimer.unref();
+    }
+  }
+  return singletonStore;
+}
+function clampTaskTtl(requestedTtl) {
+  if (requestedTtl === void 0 || requestedTtl === null) {
+    return DEFAULT_TASK_TTL_MS;
+  }
+  if (requestedTtl > MAX_TASK_TTL_MS) {
+    logger.warn("Task TTL clamped to maximum", {
+      requested: requestedTtl,
+      max: MAX_TASK_TTL_MS
+    });
+    return MAX_TASK_TTL_MS;
+  }
+  return requestedTtl;
+}
+function evictExcessTasks() {
+  if (singletonStore === void 0) return;
+  const allTasks = singletonStore.getAllTasks();
+  if (allTasks.length <= MAX_TASK_CAPACITY) return;
+  const sorted = [...allTasks].sort(
+    (a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime()
+  );
+  const evictCount = sorted.length - MAX_TASK_CAPACITY;
+  for (let i = 0; i < evictCount; i++) {
+    const task = sorted[i];
+    if (task === void 0) continue;
+    singletonStore.updateTaskStatus(task.taskId, "cancelled", "Evicted: capacity exceeded").catch((err2) => {
+      logger.debug("Failed to evict task", {
+        taskId: task.taskId,
+        error: String(err2)
+      });
+    });
+  }
+  logger.info("Evicted excess tasks", { evicted: evictCount, total: sorted.length });
+}
+
+// src/mcp/server.ts
+var DEFAULT_SERVER_NAME = "nexus-agents";
+function createServerError(code, message, error) {
+  const serverError = { code, message };
+  if (error instanceof Error) {
+    serverError.cause = error;
+  }
+  return serverError;
+}
+function createServer(config) {
+  const serverName = config?.name ?? DEFAULT_SERVER_NAME;
+  const serverVersion = config?.version ?? VERSION;
+  const logger2 = config?.logger ?? createLogger({ component: "mcp-server" });
+  try {
+    initDataDirectories();
+    logger2.info("Creating MCP server", {
+      name: serverName,
+      version: serverVersion
+    });
+    const server = new McpServer(
+      {
+        name: serverName,
+        version: serverVersion
+      },
+      {
+        capabilities: {
+          logging: {},
+          prompts: {},
+          resources: {},
+          tasks: {}
+        },
+        taskStore: getTaskStore()
+      }
+    );
+    logger2.debug("MCP server created successfully");
+    return ok({ server, logger: logger2 });
+  } catch (error) {
+    const errorMessage = getErrorMessage(error);
+    logger2.error("Failed to create MCP server", error instanceof Error ? error : void 0);
+    return err(
+      createServerError(
+        "SERVER_CREATION_FAILED",
+        `Failed to create MCP server: ${errorMessage}`,
+        error
+      )
+    );
+  }
+}
+async function connectTransport(server, transport, logger2) {
+  const log = logger2 ?? createLogger({ component: "mcp-server" });
+  try {
+    log.info("Connecting server to transport");
+    await server.connect(transport);
+    log.debug("Server connected to transport successfully");
+    return ok(void 0);
+  } catch (error) {
+    const errorMessage = getErrorMessage(error);
+    log.error("Failed to connect to transport", error instanceof Error ? error : void 0);
+    return err(
+      createServerError(
+        "SERVER_START_FAILED",
+        `Failed to connect to transport: ${errorMessage}`,
+        error
+      )
+    );
+  }
+}
+async function startStdioServer(config) {
+  const serverResult = createServer(config);
+  if (!serverResult.ok) {
+    return serverResult;
+  }
+  const { server, logger: logger2 } = serverResult.value;
+  try {
+    logger2.info("Starting stdio transport");
+    const transport = new StdioServerTransport();
+    const connectResult = await connectTransport(server, transport, logger2);
+    if (!connectResult.ok) {
+      return connectResult;
+    }
+    logger2.info("MCP server running with stdio transport");
+    return ok({ server, logger: logger2 });
+  } catch (error) {
+    const errorMessage = getErrorMessage(error);
+    logger2.error("Failed to start stdio server", error instanceof Error ? error : void 0);
+    return err(
+      createServerError(
+        "SERVER_START_FAILED",
+        `Failed to start stdio server: ${errorMessage}`,
+        error
+      )
+    );
+  }
+}
+async function closeServer(server, logger2) {
+  const log = logger2 ?? createLogger({ component: "mcp-server" });
+  try {
+    log.info("Closing MCP server");
+    await server.close();
+    log.info("MCP server closed successfully");
+    return ok(void 0);
+  } catch (error) {
+    const errorMessage = getErrorMessage(error);
+    log.error("Failed to close server", error instanceof Error ? error : void 0);
+    return err(
+      createServerError("SERVER_STOP_FAILED", `Failed to close server: ${errorMessage}`, error)
+    );
+  }
+}
+
+// src/cli/doctor-formatting.ts
+var REQUIRED_NODE_MAJOR = 22;
+function formatStatus(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(
+    `${formatStatus(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(`${formatStatus(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(
+    `${formatStatus(true)} Complex reasoning: ${colors.bold}${capitalize(bestReasoning.name)}${colors.reset}`
+  );
+  writeLine(
+    `${formatStatus(true)} Large context: ${colors.bold}${capitalize(bestContext.name)}${colors.reset} (${contextTokensK}K tokens)`
+  );
+  writeLine(
+    `${formatStatus(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(`${formatStatus(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(
+    `${formatStatus(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(`${formatStatus(true)} Configuration loaded: ${check.path}`);
+  } else {
+    writeLine(`${formatStatus(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(`${formatStatus(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}`);
+    }
+  }
+  const ageText = `${String(advisory.registryAgeDays)} days old`;
+  if (advisory.registryStale) {
+    writeLine(
+      `${colors.yellow}${symbols.warn}${colors.reset} Model registry is ${ageText} \u2014 may have stale model data`
+    );
+    writeLine(`  ${colors.dim}Run: npx tsx scripts/probe-models.ts${colors.reset}`);
+  } else {
+    writeLine(`${formatStatus(true)} Model registry: ${ageText}`);
+  }
+}
+function printLearningPersistence(check) {
+  if (!check.enabled) {
+    writeLine(`${formatStatus(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(`${formatStatus(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(
+      `${formatStatus(true)} SQLite (better-sqlite3): ${colors.green}Available${colors.reset}`
+    );
+  } else {
+    writeLine(
+      `${formatStatus(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;
+    const allWritable = check.subdirectories.every((d) => !d.exists || d.writable);
+    const healthy = allExist && allWritable;
+    writeLine(
+      `${formatStatus(healthy, !healthy)} 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}`);
+    }
+    if (!allWritable) {
+      const readonly_ = check.subdirectories.filter((d) => d.exists && !d.writable);
+      for (const dir of readonly_) {
+        writeLine(`  ${colors.yellow}Not writable: ${dir.name}/${colors.reset}`);
+      }
+    }
+  } else {
+    writeLine(
+      `${formatStatus(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(
+    `${formatStatus(result.mcpServerReady)} MCP Server mode: ${result.mcpServerReady ? "Ready" : "Not ready"}`
+  );
+  writeLine(
+    `${formatStatus(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 (existsSync(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 = cliName.length > 0 && 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 };
+  });
+  const STALE_THRESHOLD_DAYS = 30;
+  const updatedAt = new Date(DEFAULT_MODEL_CAPABILITIES.updatedAt);
+  const nowMs = getTimeProvider().now();
+  const ageDays = Math.floor((nowMs - updatedAt.getTime()) / (1e3 * 60 * 60 * 24));
+  return {
+    totalModels: models.length,
+    availableModels: models.filter((m) => m.available).length,
+    unavailableModels: models.filter((m) => !m.available).length,
+    models,
+    registryAgeDays: ageDays,
+    registryStale: ageDays > STALE_THRESHOLD_DAYS
+  };
+}
+function countJsonlLines(filePath) {
+  if (!existsSync(filePath)) return 0;
+  return readFileSync(filePath, "utf-8").split("\n").filter((l) => l.trim().length > 0).length;
+}
+function readRulesMetadata(filePath) {
+  if (!existsSync(filePath)) return { count: 0, savedAt: null };
+  try {
+    const raw = JSON.parse(readFileSync(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 = existsSync(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 = join(homedir(), ".nexus-agents");
+  const rootExists = existsSync(rootPath);
+  const subdirectories = DATA_SUBDIRECTORIES.map((name) => {
+    const fullPath = join(rootPath, name);
+    const exists = existsSync(fullPath);
+    return { name, path: fullPath, exists, writable: exists && isWritable(fullPath) };
+  });
+  return { rootExists, rootPath, subdirectories };
+}
+function isWritable(dirPath) {
+  try {
+    accessSync(dirPath, fsConstants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+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 writeLine2 = (text) => {
+    process.stdout.write(text + "\n");
+  };
+  writeLine2("");
+  writeLine2("\x1B[1mAuto-fix\x1B[0m");
+  writeLine2("\u2500".repeat(40));
+  let fixCount = 0;
+  if (!result.dataDirectory.rootExists || result.dataDirectory.subdirectories.some((d) => !d.exists || !d.writable)) {
+    const { runSetup } = await import("./setup-command-IQ4MD3FT.js");
+    const setupResult = runSetup({
+      skipMcp: true,
+      skipRules: true,
+      skipHooks: true,
+      skipConfig: true,
+      skipOpencode: true
+    });
+    if (setupResult.success) {
+      writeLine2("\u2713 Created missing data directories");
+      fixCount++;
+    }
+  }
+  if (!result.configFile.found) {
+    const { runConfigInitSync } = await import("./setup-config-5YUPLDXF.js");
+    const configResult = runConfigInitSync(process.cwd(), false, false);
+    if (configResult.success && configResult.created) {
+      writeLine2(`\u2713 Generated config: ${configResult.path}`);
+      fixCount++;
+    }
+  }
+  if (!result.sqliteCheck.available) {
+    writeLine2("");
+    writeLine2("\u26A0 better-sqlite3 not installed (manual step required):");
+    writeLine2("  npm install -g better-sqlite3");
+  }
+  if (fixCount > 0) {
+    writeLine2("");
+    writeLine2(
+      `\x1B[32m${String(fixCount)} issue(s) fixed.\x1B[0m Re-run \x1B[1mnexus-agents doctor\x1B[0m to verify.`
+    );
+  } else {
+    writeLine2("No auto-fixable issues found.");
+  }
+  writeLine2("");
+}
+
+// src/cli/setup-data-dir.ts
+var NEXUS_DATA_DIR = join2(homedir2(), ".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(join2(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 (existsSync2(dirPath)) {
+    alreadyExisted.push(dirPath);
+    return;
+  }
+  if (!dryRun) {
+    mkdirSync(dirPath, { recursive: true, ...mode !== void 0 ? { mode } : {} });
+  }
+  created.push(dirPath);
+}
+
+export {
+  VERSION,
+  DEFAULT_TASK_TTL_MS,
+  clampTaskTtl,
+  runDoctor,
+  doctorCommand,
+  initDataDirectories,
+  createServer,
+  connectTransport,
+  startStdioServer,
+  closeServer
+};
+//# sourceMappingURL=chunk-5VZLXMO7.js.map