nexus-agents 2.28.0 → 2.29.1

package/dist/chunk-BQ4YXGGQ.js

@@ -0,0 +1,127 @@
+// src/indexer/symbol-extractor.ts
+import { readFile } from "fs/promises";
+import { extname } from "path";
+import ts from "typescript";
+function getKind(node) {
+  if (ts.isFunctionDeclaration(node)) return "function";
+  if (ts.isClassDeclaration(node)) return "class";
+  if (ts.isInterfaceDeclaration(node)) return "interface";
+  if (ts.isTypeAliasDeclaration(node)) return "type";
+  if (ts.isEnumDeclaration(node)) return "enum";
+  if (ts.isMethodDeclaration(node)) return "method";
+  if (ts.isVariableStatement(node)) return "variable";
+  return null;
+}
+function getName(node) {
+  if (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isMethodDeclaration(node)) {
+    const nameNode = node.name;
+    return nameNode ? nameNode.getText() : "<anonymous>";
+  }
+  if (ts.isVariableStatement(node)) {
+    const decls = node.declarationList.declarations;
+    const firstDecl = decls[0];
+    if (firstDecl !== void 0) {
+      return firstDecl.name.getText();
+    }
+  }
+  return "<anonymous>";
+}
+function isExported(node) {
+  const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+  if (modifiers) {
+    return modifiers.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+  }
+  return false;
+}
+function visitNode(node, sourceFile, symbols) {
+  const kind = getKind(node);
+  if (kind !== null) {
+    const name = getName(node);
+    if (name !== "<anonymous>") {
+      const start = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+      const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+      symbols.push({
+        name,
+        kind,
+        startLine: start.line + 1,
+        endLine: end.line + 1,
+        text: node.getText(sourceFile),
+        exported: isExported(node)
+      });
+    }
+  }
+  if (ts.isClassDeclaration(node)) {
+    visitClassMembers(node, sourceFile, symbols);
+    return;
+  }
+  ts.forEachChild(node, (child) => {
+    visitNode(child, sourceFile, symbols);
+  });
+}
+function visitClassMembers(node, sourceFile, symbols) {
+  for (const member of node.members) {
+    if (ts.isMethodDeclaration(member) || ts.isPropertyDeclaration(member)) {
+      const memberName = member.name.getText();
+      if (memberName !== "<anonymous>") {
+        const start = sourceFile.getLineAndCharacterOfPosition(member.getStart());
+        const end = sourceFile.getLineAndCharacterOfPosition(member.getEnd());
+        symbols.push({
+          name: memberName,
+          kind: "method",
+          startLine: start.line + 1,
+          endLine: end.line + 1,
+          text: member.getText(sourceFile),
+          exported: false
+        });
+      }
+    }
+  }
+}
+function computeSavings(totalChars, symbolChars) {
+  return totalChars > 0 ? Math.round(100 * (1 - symbolChars / totalChars) * 10) / 10 : 0;
+}
+async function extractSymbols(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  if (![".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
+    return {
+      filePath,
+      symbols: [],
+      totalLines: 0,
+      totalChars: 0,
+      symbolChars: 0,
+      savingsPercent: 0
+    };
+  }
+  const source = await readFile(filePath, "utf-8");
+  const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true);
+  const symbols = [];
+  ts.forEachChild(sourceFile, (node) => {
+    visitNode(node, sourceFile, symbols);
+  });
+  const totalChars = source.length;
+  const symbolChars = symbols.reduce((sum, s) => sum + s.text.length, 0);
+  return {
+    filePath,
+    symbols,
+    totalLines: source.split("\n").length,
+    totalChars,
+    symbolChars,
+    savingsPercent: computeSavings(totalChars, symbolChars)
+  };
+}
+async function extractSymbolIndex(filePath) {
+  const result = await extractSymbols(filePath);
+  if (result.symbols.length === 0) return "";
+  const lines = result.symbols.map((s) => {
+    const exp = s.exported ? "export " : "";
+    return `${exp}${s.kind} ${s.name} (L${String(s.startLine)}-${String(s.endLine)})`;
+  });
+  return `// ${filePath} \u2014 ${String(result.symbols.length)} symbols
+${lines.join("\n")}`;
+}
+
+export {
+  extractSymbols,
+  extractSymbolIndex
+};
+//# sourceMappingURL=chunk-BQ4YXGGQ.js.map

package/dist/chunk-BQ4YXGGQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/indexer/symbol-extractor.ts"],"sourcesContent":["/**\n * AST symbol extraction for token-efficient code retrieval.\n *\n * Uses TypeScript's compiler API to extract function, class, method,\n * interface, and type definitions from source files.\n *\n * Token savings: ~80-99% vs reading full files.\n * No additional dependencies — uses TypeScript (already a project dep).\n *\n * @module indexer/symbol-extractor\n */\n\nimport { readFile } from 'node:fs/promises';\nimport { extname } from 'node:path';\nimport ts from 'typescript';\n\n/** A symbol extracted from source code. */\nexport interface CodeSymbol {\n  /** Symbol name */\n  name: string;\n  /** Symbol kind */\n  kind: 'function' | 'class' | 'method' | 'interface' | 'type' | 'variable' | 'enum';\n  /** Start line (1-based) */\n  startLine: number;\n  /** End line (1-based) */\n  endLine: number;\n  /** Full source text of the symbol */\n  text: string;\n  /** Whether the symbol is exported */\n  exported: boolean;\n}\n\n/** Result of extracting symbols from a file. */\nexport interface SymbolExtractionResult {\n  filePath: string;\n  symbols: CodeSymbol[];\n  totalLines: number;\n  totalChars: number;\n  symbolChars: number;\n  savingsPercent: number;\n}\n\nfunction getKind(node: ts.Node): CodeSymbol['kind'] | null {\n  if (ts.isFunctionDeclaration(node)) return 'function';\n  if (ts.isClassDeclaration(node)) return 'class';\n  if (ts.isInterfaceDeclaration(node)) return 'interface';\n  if (ts.isTypeAliasDeclaration(node)) return 'type';\n  if (ts.isEnumDeclaration(node)) return 'enum';\n  if (ts.isMethodDeclaration(node)) return 'method';\n  if (ts.isVariableStatement(node)) return 'variable';\n  return null;\n}\n\nfunction getName(node: ts.Node): string {\n  if (\n    ts.isFunctionDeclaration(node) ||\n    ts.isClassDeclaration(node) ||\n    ts.isInterfaceDeclaration(node) ||\n    ts.isTypeAliasDeclaration(node) ||\n    ts.isEnumDeclaration(node) ||\n    ts.isMethodDeclaration(node)\n  ) {\n    const nameNode = (node as ts.NamedDeclaration).name;\n    return nameNode ? nameNode.getText() : '<anonymous>';\n  }\n  if (ts.isVariableStatement(node)) {\n    const decls = node.declarationList.declarations;\n    const firstDecl = decls[0];\n    if (firstDecl !== undefined) {\n      return firstDecl.name.getText();\n    }\n  }\n  return '<anonymous>';\n}\n\nfunction isExported(node: ts.Node): boolean {\n  const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;\n  if (modifiers) {\n    return modifiers.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);\n  }\n  return false;\n}\n\nfunction visitNode(node: ts.Node, sourceFile: ts.SourceFile, symbols: CodeSymbol[]): void {\n  const kind = getKind(node);\n  if (kind !== null) {\n    const name = getName(node);\n    if (name !== '<anonymous>') {\n      const start = sourceFile.getLineAndCharacterOfPosition(node.getStart());\n      const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());\n      symbols.push({\n        name,\n        kind,\n        startLine: start.line + 1,\n        endLine: end.line + 1,\n        text: node.getText(sourceFile),\n        exported: isExported(node),\n      });\n    }\n  }\n  if (ts.isClassDeclaration(node)) {\n    visitClassMembers(node, sourceFile, symbols);\n    return;\n  }\n  ts.forEachChild(node, (child) => {\n    visitNode(child, sourceFile, symbols);\n  });\n}\n\nfunction visitClassMembers(\n  node: ts.ClassDeclaration,\n  sourceFile: ts.SourceFile,\n  symbols: CodeSymbol[]\n): void {\n  for (const member of node.members) {\n    if (ts.isMethodDeclaration(member) || ts.isPropertyDeclaration(member)) {\n      const memberName = member.name.getText();\n      if (memberName !== '<anonymous>') {\n        const start = sourceFile.getLineAndCharacterOfPosition(member.getStart());\n        const end = sourceFile.getLineAndCharacterOfPosition(member.getEnd());\n        symbols.push({\n          name: memberName,\n          kind: 'method',\n          startLine: start.line + 1,\n          endLine: end.line + 1,\n          text: member.getText(sourceFile),\n          exported: false,\n        });\n      }\n    }\n  }\n}\n\nfunction computeSavings(totalChars: number, symbolChars: number): number {\n  return totalChars > 0 ? Math.round(100 * (1 - symbolChars / totalChars) * 10) / 10 : 0;\n}\n\n/**\n * Extract symbols from a TypeScript/JavaScript file.\n */\nexport async function extractSymbols(filePath: string): Promise<SymbolExtractionResult> {\n  const ext = extname(filePath).toLowerCase();\n  if (!['.ts', '.tsx', '.js', '.jsx'].includes(ext)) {\n    return {\n      filePath,\n      symbols: [],\n      totalLines: 0,\n      totalChars: 0,\n      symbolChars: 0,\n      savingsPercent: 0,\n    };\n  }\n\n  const source = await readFile(filePath, 'utf-8');\n  const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true);\n  const symbols: CodeSymbol[] = [];\n\n  ts.forEachChild(sourceFile, (node) => {\n    visitNode(node, sourceFile, symbols);\n  });\n\n  const totalChars = source.length;\n  const symbolChars = symbols.reduce((sum, s) => sum + s.text.length, 0);\n\n  return {\n    filePath,\n    symbols,\n    totalLines: source.split('\\n').length,\n    totalChars,\n    symbolChars,\n    savingsPercent: computeSavings(totalChars, symbolChars),\n  };\n}\n\n/**\n * Extract a compact symbol index (names + locations only, no source text).\n * This is the minimal representation for LLM context — ~95%+ token savings.\n */\nexport async function extractSymbolIndex(filePath: string): Promise<string> {\n  const result = await extractSymbols(filePath);\n  if (result.symbols.length === 0) return '';\n\n  const lines = result.symbols.map((s) => {\n    const exp = s.exported ? 'export ' : '';\n    return `${exp}${s.kind} ${s.name} (L${String(s.startLine)}-${String(s.endLine)})`;\n  });\n\n  return `// ${filePath} — ${String(result.symbols.length)} symbols\\n${lines.join('\\n')}`;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-C2C5ONFR.js

@@ -0,0 +1,195 @@
+import {
+  CircuitBreakerRegistry,
+  CircuitError,
+  mapCliErrorToCategory
+} from "./chunk-LLGUX44Z.js";
+import {
+  createLogger,
+  err,
+  getTimeProvider,
+  ok
+} from "./chunk-ELIFTCYM.js";
+
+// src/cli-adapters/fallback-chains.ts
+import { z } from "zod";
+var FallbackChainSchema = z.array(z.enum(["claude", "gemini", "codex", "opencode"])).min(1).readonly();
+var FallbackChainRegistrySchema = z.object({
+  code: FallbackChainSchema,
+  research: FallbackChainSchema,
+  documentation: FallbackChainSchema,
+  analysis: FallbackChainSchema,
+  general: FallbackChainSchema
+});
+var DEFAULT_FALLBACK_CHAINS = {
+  // code_generation/code_review/testing: codex primary, claude secondary
+  code: ["codex", "claude", "gemini", "opencode"],
+  // research/exploration: gemini primary, claude secondary
+  research: ["gemini", "claude", "codex", "opencode"],
+  // documentation: gemini primary, claude secondary
+  documentation: ["gemini", "claude", "codex", "opencode"],
+  // architecture/security/planning: claude primary, gemini secondary
+  // Weather data: gemini arch 66.7% (n=24) > codex 33.3% (n=3)
+  analysis: ["claude", "gemini", "codex", "opencode"],
+  // general: balanced order
+  general: ["claude", "gemini", "codex", "opencode"]
+};
+var CATEGORY_CHAIN_OVERRIDES = {
+  architecture: ["gemini", "claude", "codex", "opencode"],
+  security_review: ["codex", "gemini", "claude", "opencode"],
+  code_review: ["claude", "codex", "gemini", "opencode"],
+  exploration: ["gemini", "codex", "claude", "opencode"],
+  devops: ["claude", "gemini", "codex", "opencode"],
+  // codex has 15% research success (n=20) — push to last position (#1536)
+  research: ["gemini", "claude", "opencode", "codex"],
+  // codex has 33.3% docs success (n=6) — push to last position (#1536)
+  documentation: ["gemini", "claude", "opencode", "codex"]
+};
+function getFallbackChainForCategory(category, bucketType, registry = DEFAULT_FALLBACK_CHAINS) {
+  const override = CATEGORY_CHAIN_OVERRIDES[category];
+  if (override !== void 0) return override;
+  return registry[bucketType];
+}
+
+// src/cli-adapters/cli-circuit-breaker.ts
+var CATEGORY_TO_FALLBACK = {
+  code_generation: "code",
+  code_review: "code",
+  testing: "code",
+  research: "research",
+  exploration: "research",
+  documentation: "documentation",
+  architecture: "analysis",
+  security_review: "analysis",
+  planning: "analysis",
+  devops: "general"
+};
+var DEFAULT_FALLBACK_CHAIN = ["claude", "gemini", "codex", "opencode"];
+var DEFAULT_CONFIG = {
+  perCliConfig: {},
+  fallbackChain: DEFAULT_FALLBACK_CHAIN,
+  enableFallback: true,
+  maxFallbackAttempts: 2
+};
+var CliCircuitBreakerIntegration = class {
+  registry;
+  adapters = /* @__PURE__ */ new Map();
+  config;
+  logger;
+  constructor(adapters, config, logger) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.logger = logger ?? createLogger({ component: "cli-circuit-breaker-integration" });
+    this.registry = new CircuitBreakerRegistry();
+    for (const adapter of adapters) {
+      this.adapters.set(adapter.name, adapter);
+      this.registry.getBreaker(adapter.name, this.config.perCliConfig[adapter.name]);
+    }
+  }
+  async execute(adapter, task, taskCategory) {
+    const primaryCli = adapter.name;
+    const fallbackAttempts = [];
+    let lastError;
+    const primaryResult = await this.executeWithBreaker(adapter, task);
+    if (primaryResult.ok) {
+      return ok({ response: primaryResult.value, executedBy: primaryCli, usedFallback: false });
+    }
+    lastError = primaryResult.error;
+    if (!this.config.enableFallback || !(lastError instanceof CircuitError)) {
+      return err(lastError);
+    }
+    for (const cli of this.getFallbackClis(primaryCli, taskCategory).slice(
+      0,
+      this.config.maxFallbackAttempts
+    )) {
+      const fallbackAdapter = this.adapters.get(cli);
+      if (!fallbackAdapter) continue;
+      fallbackAttempts.push(cli);
+      this.logger.info("Attempting fallback", { from: primaryCli, to: cli });
+      const result = await this.executeWithBreaker(fallbackAdapter, task);
+      if (result.ok) {
+        return ok({
+          response: result.value,
+          executedBy: cli,
+          usedFallback: true,
+          fallbackAttempts
+        });
+      }
+      lastError = result.error;
+    }
+    this.logger.warn("All fallback attempts failed", { primaryCli, fallbackAttempts });
+    return err(lastError);
+  }
+  getHealthStatus() {
+    const snapshots = this.registry.getAllSnapshots();
+    const clis = [];
+    let healthyCount = 0;
+    for (const name of this.adapters.keys()) {
+      const snapshot = snapshots.get(name);
+      if (!snapshot) continue;
+      const healthy = snapshot.state === "closed";
+      if (healthy) healthyCount++;
+      clis.push({
+        name,
+        healthy,
+        circuitState: snapshot.state,
+        failureCount: snapshot.failureCount,
+        lastFailureTime: snapshot.lastFailureTime
+      });
+    }
+    return {
+      clis,
+      systemHealthy: healthyCount > 0,
+      healthyCount,
+      timestamp: getTimeProvider().now()
+    };
+  }
+  getCircuitSnapshots() {
+    return this.registry.getAllSnapshots();
+  }
+  resetCircuit(cliName) {
+    this.registry.reset(cliName);
+    this.logger.info("Circuit reset", { cliName });
+  }
+  resetAllCircuits() {
+    this.registry.resetAll();
+    this.logger.info("All circuits reset");
+  }
+  addStateChangeListener(listener) {
+    this.registry.addGlobalStateChangeListener(listener);
+  }
+  async executeWithBreaker(adapter, task) {
+    const breaker = this.registry.getBreaker(adapter.name);
+    const result = await breaker.execute(async () => {
+      const execResult = await adapter.execute(task);
+      if (!execResult.ok) {
+        breaker.recordFailure(mapCliErrorToCategory(execResult.error.code));
+        const wrappedError = new Error(execResult.error.message);
+        wrappedError.cliError = execResult.error;
+        throw wrappedError;
+      }
+      return execResult.value;
+    });
+    if (!result.ok) {
+      if (result.error.circuitErrorCode === "CIRCUIT_OPEN") return err(result.error);
+      const wrapped = result.error.cause;
+      if (wrapped?.cliError) return err(wrapped.cliError);
+      return err(result.error);
+    }
+    return ok(result.value);
+  }
+  getFallbackClis(excludeCli, taskCategory) {
+    const chain = taskCategory !== void 0 ? getFallbackChainForCategory(taskCategory, CATEGORY_TO_FALLBACK[taskCategory]) : this.config.fallbackChain;
+    return [...chain].filter(
+      (cli) => cli !== excludeCli && !this.registry.isOpen(cli) && this.adapters.has(cli)
+    );
+  }
+};
+function createCliCircuitBreakerIntegration(adapters, config, logger) {
+  return new CliCircuitBreakerIntegration(adapters, config, logger);
+}
+
+export {
+  getFallbackChainForCategory,
+  CliCircuitBreakerIntegration,
+  createCliCircuitBreakerIntegration
+};
+//# sourceMappingURL=chunk-C2C5ONFR.js.map

package/dist/chunk-C2C5ONFR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli-adapters/fallback-chains.ts","../src/cli-adapters/cli-circuit-breaker.ts"],"sourcesContent":["/**\n * nexus-agents/cli-adapters - Fallback Chain Registry\n *\n * Configurable fallback chains per task type with metrics tracking.\n * Provides ordered CLI preferences based on task classification.\n *\n * @module cli-adapters/fallback-chains\n * (Source: Issue #362 - Task-type-aware fallback chains)\n */\n\nimport { z } from 'zod';\nimport type { CliName } from './types-core.js';\nimport type { FallbackTaskType } from './task-classifier.js';\nimport type { TaskCategory } from '../config/task-specialization-types.js';\n\n/**\n * Fallback chain: ordered list of CLIs to try for a task type.\n */\nexport type FallbackChain = readonly CliName[];\n\n/**\n * Registry mapping task types to fallback chains.\n */\nexport type FallbackChainRegistry = Readonly<Record<FallbackTaskType, FallbackChain>>;\n\n/**\n * Metrics for tracking fallback chain success rates.\n */\nexport interface FallbackChainMetrics {\n  /** Total attempts for this task type */\n  readonly totalAttempts: number;\n  /** Successes by position in chain (0-indexed) */\n  readonly successByPosition: readonly number[];\n  /** Failures (exhausted all positions) */\n  readonly exhaustedCount: number;\n  /** Average position of successful attempt (lower is better) */\n  readonly avgSuccessPosition: number;\n}\n\n/**\n * Metrics for all task types.\n */\nexport type FallbackMetricsRegistry = Readonly<Record<FallbackTaskType, FallbackChainMetrics>>;\n\n/**\n * Outcome of a fallback chain execution.\n */\nexport interface FallbackOutcome {\n  /** Task type that was classified */\n  readonly taskType: FallbackTaskType;\n  /** Position in chain that succeeded (0-indexed), or -1 if exhausted */\n  readonly successPosition: number;\n  /** CLI that succeeded, or undefined if exhausted */\n  readonly successfulCli?: CliName | undefined;\n  /** Whether the chain was exhausted without success */\n  readonly exhausted: boolean;\n}\n\n/**\n * Zod schema for fallback chain validation.\n */\nexport const FallbackChainSchema = z\n  .array(z.enum(['claude', 'gemini', 'codex', 'opencode']))\n  .min(1)\n  .readonly();\n\n/**\n * Zod schema for fallback chain registry.\n */\nexport const FallbackChainRegistrySchema = z.object({\n  code: FallbackChainSchema,\n  research: FallbackChainSchema,\n  documentation: FallbackChainSchema,\n  analysis: FallbackChainSchema,\n  general: FallbackChainSchema,\n});\n\n/**\n * Default fallback chains derived from the task specialization matrix.\n * Each chain orders CLIs by: primary → secondary → others.\n *\n * - code: Codex primary (92.4% code_gen), Claude secondary\n * - research: Gemini primary (86.8% research), Claude secondary\n * - documentation: Gemini primary (71.4% docs), Claude secondary\n * - analysis: Claude primary (architecture/security/planning), Codex secondary\n * - general: Balanced fallback order\n */\nexport const DEFAULT_FALLBACK_CHAINS: FallbackChainRegistry = {\n  // code_generation/code_review/testing: codex primary, claude secondary\n  code: ['codex', 'claude', 'gemini', 'opencode'],\n  // research/exploration: gemini primary, claude secondary\n  research: ['gemini', 'claude', 'codex', 'opencode'],\n  // documentation: gemini primary, claude secondary\n  documentation: ['gemini', 'claude', 'codex', 'opencode'],\n  // architecture/security/planning: claude primary, gemini secondary\n  // Weather data: gemini arch 66.7% (n=24) > codex 33.3% (n=3)\n  analysis: ['claude', 'gemini', 'codex', 'opencode'],\n  // general: balanced order\n  general: ['claude', 'gemini', 'codex', 'opencode'],\n} as const;\n\n/**\n * Per-category fallback chain overrides.\n *\n * Categories in the same FallbackTaskType bucket may need different CLI ordering.\n * Entries here override the bucket-level chain from DEFAULT_FALLBACK_CHAINS.\n *\n * Weather data 2026-03-09:\n * - architecture: gemini 69.6% (n=23) > claude 40.9% (n=235) → gemini first\n * - planning: claude 92.2% → keep claude first (bucket default)\n * - security_review: codex 60% (n=5) > gemini 53.8% (n=13) > claude 54.2% (n=382) → codex first\n * - exploration: gemini 100% (n=307) > claude 83.9% (n=380) → gemini first, codex secondary (#1526)\n * - devops: claude 80% (n=5), gemini 100% (n=1) → keep claude first, gemini secondary (#1526)\n * - research: gemini 86.8% (n=38) > claude 84.1% (n=44) > codex 15% (n=20) → gemini first, codex last (#1536)\n * - documentation: gemini 71.4% (n=35) > claude 64.7% (n=17) > codex 33.3% (n=6) → gemini first, codex last (#1536)\n * - code_review: claude 91% (n=200) > codex 89.2% (n=93) > gemini 37.5% (n=8) → claude first (#1401)\n */\nexport const CATEGORY_CHAIN_OVERRIDES: Partial<Record<TaskCategory, FallbackChain>> = {\n  architecture: ['gemini', 'claude', 'codex', 'opencode'],\n  security_review: ['codex', 'gemini', 'claude', 'opencode'],\n  code_review: ['claude', 'codex', 'gemini', 'opencode'],\n  exploration: ['gemini', 'codex', 'claude', 'opencode'],\n  devops: ['claude', 'gemini', 'codex', 'opencode'],\n  // codex has 15% research success (n=20) — push to last position (#1536)\n  research: ['gemini', 'claude', 'opencode', 'codex'],\n  // codex has 33.3% docs success (n=6) — push to last position (#1536)\n  documentation: ['gemini', 'claude', 'opencode', 'codex'],\n} as const;\n\n/**\n * Gets the fallback chain for a specific TaskCategory.\n * Returns a category-specific override if available, otherwise falls through\n * to the bucket-level chain via CATEGORY_TO_FALLBACK mapping.\n */\nexport function getFallbackChainForCategory(\n  category: TaskCategory,\n  bucketType: FallbackTaskType,\n  registry: FallbackChainRegistry = DEFAULT_FALLBACK_CHAINS\n): FallbackChain {\n  const override = CATEGORY_CHAIN_OVERRIDES[category];\n  if (override !== undefined) return override;\n  return registry[bucketType];\n}\n\n/**\n * Creates initial empty metrics for a task type.\n */\nfunction createEmptyMetrics(): FallbackChainMetrics {\n  return {\n    totalAttempts: 0,\n    successByPosition: [0, 0, 0, 0],\n    avgSuccessPosition: 0,\n    exhaustedCount: 0,\n  };\n}\n\n/**\n * Creates initial metrics registry with empty metrics for all types.\n */\nfunction createEmptyMetricsRegistry(): Record<FallbackTaskType, FallbackChainMetrics> {\n  return {\n    code: createEmptyMetrics(),\n    research: createEmptyMetrics(),\n    documentation: createEmptyMetrics(),\n    analysis: createEmptyMetrics(),\n    general: createEmptyMetrics(),\n  };\n}\n\n/**\n * Gets the fallback chain for a task type.\n *\n * @param taskType - Task type to get chain for\n * @param registry - Optional custom registry (uses default if not provided)\n * @returns Ordered list of CLIs to try\n *\n * @example\n * ```typescript\n * const chain = getFallbackChain('code');\n * // chain === ['claude', 'codex', 'gemini']\n * ```\n */\nexport function getFallbackChain(\n  taskType: FallbackTaskType,\n  registry: FallbackChainRegistry = DEFAULT_FALLBACK_CHAINS\n): FallbackChain {\n  return registry[taskType];\n}\n\n/**\n * Filters a fallback chain to only include available CLIs.\n *\n * @param chain - Original fallback chain\n * @param availableClis - Set of currently available CLI names\n * @returns Filtered chain with only available CLIs\n *\n * @example\n * ```typescript\n * const filtered = filterAvailableClis(['claude', 'codex', 'gemini'], new Set(['claude', 'gemini']));\n * // filtered === ['claude', 'gemini']\n * ```\n */\nexport function filterAvailableClis(\n  chain: FallbackChain,\n  availableClis: ReadonlySet<CliName>\n): CliName[] {\n  return chain.filter((cli) => availableClis.has(cli));\n}\n\n/**\n * Gets the next CLI to try in a fallback chain.\n *\n * @param chain - Fallback chain\n * @param currentPosition - Current position (0-indexed)\n * @returns Next CLI to try, or undefined if chain is exhausted\n */\nexport function getNextCli(chain: FallbackChain, currentPosition: number): CliName | undefined {\n  const nextPosition = currentPosition + 1;\n  return chain[nextPosition];\n}\n\n/**\n * Checks if a fallback chain is exhausted at the given position.\n *\n * @param chain - Fallback chain\n * @param currentPosition - Current position (0-indexed)\n * @returns True if no more CLIs to try\n */\nexport function isChainExhausted(chain: FallbackChain, currentPosition: number): boolean {\n  return currentPosition >= chain.length - 1;\n}\n\n/**\n * Fallback chain manager with metrics tracking.\n */\nexport class FallbackChainManager {\n  private readonly registry: FallbackChainRegistry;\n  private readonly metrics: Record<FallbackTaskType, FallbackChainMetrics>;\n\n  constructor(registry: FallbackChainRegistry = DEFAULT_FALLBACK_CHAINS) {\n    this.registry = registry;\n    this.metrics = createEmptyMetricsRegistry();\n  }\n\n  /**\n   * Gets the fallback chain for a task type.\n   */\n  getChain(taskType: FallbackTaskType): FallbackChain {\n    return getFallbackChain(taskType, this.registry);\n  }\n\n  /**\n   * Gets the chain filtered by available CLIs.\n   */\n  getAvailableChain(taskType: FallbackTaskType, availableClis: ReadonlySet<CliName>): CliName[] {\n    const chain = this.getChain(taskType);\n    return filterAvailableClis(chain, availableClis);\n  }\n\n  /**\n   * Records an outcome and updates metrics.\n   *\n   * @param outcome - The outcome to record\n   */\n  recordOutcome(outcome: FallbackOutcome): void {\n    const currentMetrics = this.metrics[outcome.taskType];\n    const newSuccessByPosition = [...currentMetrics.successByPosition];\n\n    // Update success counts\n    if (!outcome.exhausted && outcome.successPosition >= 0) {\n      const position = outcome.successPosition;\n      if (position < newSuccessByPosition.length) {\n        const currentCount = newSuccessByPosition[position] ?? 0;\n        newSuccessByPosition[position] = currentCount + 1;\n      } else {\n        // Extend array if needed\n        while (newSuccessByPosition.length <= position) {\n          newSuccessByPosition.push(0);\n        }\n        newSuccessByPosition[position] = 1;\n      }\n    }\n\n    // Calculate new average success position\n    const totalSuccesses = newSuccessByPosition.reduce((sum, count) => sum + count, 0);\n    const weightedSum = newSuccessByPosition.reduce((sum, count, pos) => sum + count * pos, 0);\n    const avgSuccessPosition = totalSuccesses > 0 ? weightedSum / totalSuccesses : 0;\n\n    // Update metrics\n    this.metrics[outcome.taskType] = {\n      totalAttempts: currentMetrics.totalAttempts + 1,\n      successByPosition: newSuccessByPosition,\n      exhaustedCount: currentMetrics.exhaustedCount + (outcome.exhausted ? 1 : 0),\n      avgSuccessPosition,\n    };\n  }\n\n  /**\n   * Gets metrics for a specific task type.\n   */\n  getMetrics(taskType: FallbackTaskType): FallbackChainMetrics {\n    return this.metrics[taskType];\n  }\n\n  /**\n   * Gets metrics for all task types.\n   */\n  getAllMetrics(): FallbackMetricsRegistry {\n    return { ...this.metrics };\n  }\n\n  /**\n   * Gets the success rate at each position for a task type.\n   *\n   * @param taskType - Task type to get rates for\n   * @returns Array of success rates (0-1) by position\n   */\n  getSuccessRatesByPosition(taskType: FallbackTaskType): readonly number[] {\n    const metrics = this.metrics[taskType];\n    if (metrics.totalAttempts === 0) {\n      return [];\n    }\n    return metrics.successByPosition.map((count) => count / metrics.totalAttempts);\n  }\n\n  /**\n   * Gets overall success rate for a task type.\n   */\n  getOverallSuccessRate(taskType: FallbackTaskType): number {\n    const metrics = this.metrics[taskType];\n    if (metrics.totalAttempts === 0) {\n      return 0;\n    }\n    const totalSuccesses = metrics.successByPosition.reduce((sum, count) => sum + count, 0);\n    return totalSuccesses / metrics.totalAttempts;\n  }\n\n  /**\n   * Resets metrics for all task types.\n   */\n  resetMetrics(): void {\n    const types: FallbackTaskType[] = ['code', 'research', 'documentation', 'analysis', 'general'];\n    for (const type of types) {\n      this.metrics[type] = createEmptyMetrics();\n    }\n  }\n}\n\n/**\n * Creates a new FallbackChainManager instance.\n *\n * @param registry - Optional custom fallback chain registry\n * @returns New FallbackChainManager instance\n */\nexport function createFallbackChainManager(registry?: FallbackChainRegistry): FallbackChainManager {\n  return new FallbackChainManager(registry);\n}\n\n/**\n * Creates a custom fallback chain registry by merging with defaults.\n *\n * @param overrides - Partial registry with overrides\n * @returns Complete registry with defaults for unspecified types\n */\nexport function createFallbackChainRegistry(\n  overrides: Partial<FallbackChainRegistry>\n): FallbackChainRegistry {\n  return {\n    ...DEFAULT_FALLBACK_CHAINS,\n    ...overrides,\n  };\n}\n","/**\n * nexus-agents/cli-adapters - CLI Circuit Breaker Integration\n *\n * Wraps CLI adapter calls with circuit breaker pattern for resilient\n * multi-CLI execution with automatic fallback on failures.\n *\n * (Source: Issue #359 - Integrate circuit breaker with CLI adapters)\n */\n\nimport type { Result, ILogger } from '../core/index.js';\nimport { ok, err, createLogger, getTimeProvider } from '../core/index.js';\nimport type { TaskCategory } from '../config/task-specialization-types.js';\nimport type { FallbackTaskType } from './task-classifier.js';\nimport { getFallbackChainForCategory } from './fallback-chains.js';\nimport type { ICliAdapter, CliName, CliTask, CliResponse, CliError } from './types.js';\nimport {\n  CircuitBreakerRegistry,\n  CircuitError,\n  mapCliErrorToCategory,\n  type CircuitBreakerConfig,\n  type CircuitBreakerSnapshot,\n  type CircuitStateChangeListener,\n} from './circuit-breaker.js';\n\n/** Maps canonical TaskCategory (10 types) to FallbackTaskType (5 types). */\nconst CATEGORY_TO_FALLBACK: Record<TaskCategory, FallbackTaskType> = {\n  code_generation: 'code',\n  code_review: 'code',\n  testing: 'code',\n  research: 'research',\n  exploration: 'research',\n  documentation: 'documentation',\n  architecture: 'analysis',\n  security_review: 'analysis',\n  planning: 'analysis',\n  devops: 'general',\n};\n\n/** Configuration for CLI circuit breaker integration. */\nexport interface CliCircuitBreakerConfig {\n  readonly perCliConfig?: Partial<Record<CliName, Partial<CircuitBreakerConfig>>>;\n  readonly fallbackChain?: ReadonlyArray<CliName>;\n  readonly enableFallback?: boolean;\n  readonly maxFallbackAttempts?: number;\n}\n\n/** Result of a circuit-protected execution with fallback info. */\nexport interface CircuitProtectedResult {\n  readonly response: CliResponse;\n  readonly executedBy: CliName;\n  readonly usedFallback: boolean;\n  readonly fallbackAttempts?: ReadonlyArray<CliName>;\n}\n\n/** Health status for all CLIs with circuit state. */\nexport interface CliCircuitHealthStatus {\n  readonly clis: ReadonlyArray<{\n    readonly name: CliName;\n    readonly healthy: boolean;\n    readonly circuitState: 'closed' | 'open' | 'half-open';\n    readonly failureCount: number;\n    readonly lastFailureTime: number | null;\n  }>;\n  readonly systemHealthy: boolean;\n  readonly healthyCount: number;\n  readonly timestamp: number;\n}\n\n/** Interface for CLI circuit breaker integration. */\nexport interface ICliCircuitBreakerIntegration {\n  execute(\n    adapter: ICliAdapter,\n    task: CliTask,\n    taskCategory?: TaskCategory\n  ): Promise<Result<CircuitProtectedResult, CircuitError | CliError>>;\n  getHealthStatus(): CliCircuitHealthStatus;\n  getCircuitSnapshots(): Map<CliName, CircuitBreakerSnapshot>;\n  resetCircuit(cliName: CliName): void;\n  resetAllCircuits(): void;\n  addStateChangeListener(listener: CircuitStateChangeListener): void;\n}\n\nconst DEFAULT_FALLBACK_CHAIN: ReadonlyArray<CliName> = ['claude', 'gemini', 'codex', 'opencode'];\nconst DEFAULT_CONFIG: Required<CliCircuitBreakerConfig> = {\n  perCliConfig: {},\n  fallbackChain: DEFAULT_FALLBACK_CHAIN,\n  enableFallback: true,\n  maxFallbackAttempts: 2,\n};\n\n/**\n * Integrates circuit breaker pattern with CLI adapters.\n * Provides automatic fallback when a CLI's circuit opens.\n */\nexport class CliCircuitBreakerIntegration implements ICliCircuitBreakerIntegration {\n  private readonly registry: CircuitBreakerRegistry;\n  private readonly adapters: Map<CliName, ICliAdapter> = new Map();\n  private readonly config: Required<CliCircuitBreakerConfig>;\n  private readonly logger: ILogger;\n\n  constructor(\n    adapters: ReadonlyArray<ICliAdapter>,\n    config?: CliCircuitBreakerConfig,\n    logger?: ILogger\n  ) {\n    this.config = { ...DEFAULT_CONFIG, ...config };\n    this.logger = logger ?? createLogger({ component: 'cli-circuit-breaker-integration' });\n    this.registry = new CircuitBreakerRegistry();\n    for (const adapter of adapters) {\n      this.adapters.set(adapter.name, adapter);\n      this.registry.getBreaker(adapter.name, this.config.perCliConfig[adapter.name]);\n    }\n  }\n\n  async execute(\n    adapter: ICliAdapter,\n    task: CliTask,\n    taskCategory?: TaskCategory\n  ): Promise<Result<CircuitProtectedResult, CircuitError | CliError>> {\n    const primaryCli = adapter.name;\n    const fallbackAttempts: CliName[] = [];\n    let lastError: CircuitError | CliError | undefined;\n\n    const primaryResult = await this.executeWithBreaker(adapter, task);\n    if (primaryResult.ok) {\n      return ok({ response: primaryResult.value, executedBy: primaryCli, usedFallback: false });\n    }\n    lastError = primaryResult.error;\n\n    if (!this.config.enableFallback || !(lastError instanceof CircuitError)) {\n      return err(lastError);\n    }\n\n    for (const cli of this.getFallbackClis(primaryCli, taskCategory).slice(\n      0,\n      this.config.maxFallbackAttempts\n    )) {\n      const fallbackAdapter = this.adapters.get(cli);\n      if (!fallbackAdapter) continue;\n      fallbackAttempts.push(cli);\n      this.logger.info('Attempting fallback', { from: primaryCli, to: cli });\n      const result = await this.executeWithBreaker(fallbackAdapter, task);\n      if (result.ok) {\n        return ok({\n          response: result.value,\n          executedBy: cli,\n          usedFallback: true,\n          fallbackAttempts,\n        });\n      }\n      lastError = result.error;\n    }\n\n    this.logger.warn('All fallback attempts failed', { primaryCli, fallbackAttempts });\n    return err(lastError);\n  }\n\n  getHealthStatus(): CliCircuitHealthStatus {\n    const snapshots = this.registry.getAllSnapshots();\n    const clis: CliCircuitHealthStatus['clis'][number][] = [];\n    let healthyCount = 0;\n    for (const name of this.adapters.keys()) {\n      const snapshot = snapshots.get(name);\n      if (!snapshot) continue;\n      const healthy = snapshot.state === 'closed';\n      if (healthy) healthyCount++;\n      clis.push({\n        name,\n        healthy,\n        circuitState: snapshot.state,\n        failureCount: snapshot.failureCount,\n        lastFailureTime: snapshot.lastFailureTime,\n      });\n    }\n    return {\n      clis,\n      systemHealthy: healthyCount > 0,\n      healthyCount,\n      timestamp: getTimeProvider().now(),\n    };\n  }\n\n  getCircuitSnapshots(): Map<CliName, CircuitBreakerSnapshot> {\n    return this.registry.getAllSnapshots();\n  }\n\n  resetCircuit(cliName: CliName): void {\n    this.registry.reset(cliName);\n    this.logger.info('Circuit reset', { cliName });\n  }\n\n  resetAllCircuits(): void {\n    this.registry.resetAll();\n    this.logger.info('All circuits reset');\n  }\n\n  addStateChangeListener(listener: CircuitStateChangeListener): void {\n    this.registry.addGlobalStateChangeListener(listener);\n  }\n\n  private async executeWithBreaker(\n    adapter: ICliAdapter,\n    task: CliTask\n  ): Promise<Result<CliResponse, CircuitError | CliError>> {\n    const breaker = this.registry.getBreaker(adapter.name);\n    const result = await breaker.execute(async () => {\n      const execResult = await adapter.execute(task);\n      if (!execResult.ok) {\n        breaker.recordFailure(mapCliErrorToCategory(execResult.error.code));\n        const wrappedError = new Error(execResult.error.message);\n        (wrappedError as Error & { cliError: CliError }).cliError = execResult.error;\n        throw wrappedError;\n      }\n      return execResult.value;\n    });\n\n    if (!result.ok) {\n      if (result.error.circuitErrorCode === 'CIRCUIT_OPEN') return err(result.error);\n      const wrapped = result.error.cause as (Error & { cliError?: CliError }) | undefined;\n      if (wrapped?.cliError) return err(wrapped.cliError);\n      return err(result.error);\n    }\n    return ok(result.value);\n  }\n\n  private getFallbackClis(excludeCli: CliName, taskCategory?: TaskCategory): CliName[] {\n    const chain =\n      taskCategory !== undefined\n        ? getFallbackChainForCategory(taskCategory, CATEGORY_TO_FALLBACK[taskCategory])\n        : this.config.fallbackChain;\n    return [...chain].filter(\n      (cli) => cli !== excludeCli && !this.registry.isOpen(cli) && this.adapters.has(cli)\n    );\n  }\n}\n\n/** Creates a CLI circuit breaker integration with the specified adapters. */\nexport function createCliCircuitBreakerIntegration(\n  adapters: ReadonlyArray<ICliAdapter>,\n  config?: CliCircuitBreakerConfig,\n  logger?: ILogger\n): CliCircuitBreakerIntegration {\n  return new CliCircuitBreakerIntegration(adapters, config, logger);\n}\n"],"mappings":"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","names":[]}