aiwcli 0.15.5 → 0.17.0

package/dist/templates/cc-native/_cc-native/lib-ts/agent-selection.ts

@@ -0,0 +1,163 @@
+/**
+ * Agent selection: mandatory resolution, orchestrator-based selection, model assignment.
+ * Extracted from cc-native-plan-review.ts.
+ */
+
+import { logDebug, logInfo, logWarn } from "../../_core/lib-ts/runtime/logger.js";
+import { findExecutable } from "../../_core/lib-ts/runtime/subprocess-utils.js";
+
+import type {
+  AgentConfig,
+  ModelsConfig,
+  OrchestratorResult,
+  AgentSelectionResult,
+} from "./types.js";
+
+const HOOK = "agent-selection";
+
+// ---------------------------------------------------------------------------
+// Mandatory Agent Resolution
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve mandatory agent names from config. Supports flat arrays or
+ * complexity-tiered objects with `always`, `medium+`, and `high` keys.
+ */
+export function resolveMandatoryAgents(
+  configValue: unknown,
+  complexity: string,
+): Set<string> {
+  if (Array.isArray(configValue)) {
+    return new Set(configValue as string[]);
+  }
+  if (!configValue || typeof configValue !== "object") {
+    return new Set(["handoff-readiness", "clarity-auditor", "skeptic"]);
+  }
+  const cfg = configValue as Record<string, string[]>;
+  const names = new Set(cfg.always ?? []);
+  if (complexity === "medium" || complexity === "high") {
+    for (const n of cfg["medium+"] ?? []) names.add(n);
+  }
+  if (complexity === "high") {
+    for (const n of cfg.high ?? []) names.add(n);
+  }
+  return names;
+}
+
+// ---------------------------------------------------------------------------
+// Model Assignment
+// ---------------------------------------------------------------------------
+
+/**
+ * Randomly assign enabled providers and models to agents.
+ * Filters to providers whose CLI is available on PATH.
+ */
+export function assignModelsToAgents(
+  agents: AgentConfig[],
+  modelsConfig: ModelsConfig,
+): AgentConfig[] {
+  const enabledProviders = Object.entries(modelsConfig.providers)
+    .filter(([name, config]) => {
+      if (!config.enabled || config.models.length === 0) return false;
+      const cliName = name === "claude" ? "claude" : name;
+      const found = findExecutable(cliName);
+      if (!found) {
+        logWarn(HOOK, `Provider '${name}' enabled but CLI '${cliName}' not found on PATH — skipping`);
+      }
+      return !!found;
+    });
+
+  if (enabledProviders.length === 0) {
+    logWarn(HOOK, "No providers with available CLI found, falling back to Claude with agent defaults");
+    return agents.map(a => ({ ...a, provider: "claude" }));
+  }
+
+  return agents.map(agent => {
+    const idx = Math.floor(Math.random() * enabledProviders.length);
+    const entry = enabledProviders[idx];
+    if (!entry) return { ...agent, provider: "claude" };
+    const [providerName, providerConfig] = entry;
+    const modelIdx = Math.floor(Math.random() * providerConfig.models.length);
+    const model = providerConfig.models[modelIdx] ?? providerConfig.models[0] ?? agent.model;
+    return { ...agent, provider: providerName, model, reasoning_effort: providerConfig.reasoning_effort };
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Agent Selection
+// ---------------------------------------------------------------------------
+
+export interface AgentSelectionInput {
+  enabledAgents: AgentConfig[];
+  orchResult: OrchestratorResult | null;
+  mandatoryConfig: unknown;
+  agentSettings: Record<string, unknown>;
+  legacyMode: boolean;
+}
+
+/**
+ * Select agents based on orchestrator result and mandatory config.
+ */
+export function selectAgents(input: AgentSelectionInput): AgentSelectionResult {
+  const { enabledAgents, orchResult, mandatoryConfig, agentSettings, legacyMode } = input;
+
+  let detectedComplexity = "medium";
+  let mandatoryNames = resolveMandatoryAgents(mandatoryConfig, "simple");
+
+  if (enabledAgents.length === 0) {
+    return { selectedAgents: [], mandatoryNames, detectedComplexity };
+  }
+
+  let mandatoryAgents = enabledAgents.filter(a => mandatoryNames.has(a.name));
+  let nonMandatory = enabledAgents.filter(a => !mandatoryNames.has(a.name));
+
+  logDebug(HOOK, `Mandatory agents: ${mandatoryAgents.map(a => a.name)}`);
+  logDebug(HOOK, `Non-mandatory pool: ${nonMandatory.length} agents`);
+
+  if (orchResult && !legacyMode) {
+    detectedComplexity = orchResult.complexity;
+
+    // Recompute mandatory with actual complexity
+    mandatoryNames = resolveMandatoryAgents(mandatoryConfig, detectedComplexity);
+    mandatoryAgents = enabledAgents.filter(a => mandatoryNames.has(a.name));
+    nonMandatory = enabledAgents.filter(a => !mandatoryNames.has(a.name));
+
+    const orchSelectedNames = new Set(
+      orchResult.selected_agents.filter(n => !mandatoryNames.has(n)),
+    );
+    let orchSelected = nonMandatory.filter(a => orchSelectedNames.has(a.name));
+
+    logDebug(HOOK, `Orchestrator selected (non-mandatory): ${orchSelected.map(a => a.name)}`);
+
+    // Warn if orchestrator returned unknown names
+    const knownNames = new Set(nonMandatory.map(a => a.name));
+    const unmatched = [...orchSelectedNames].filter(n => !knownNames.has(n));
+    if (unmatched.length > 0) {
+      logWarn(HOOK, `Orchestrator selected unknown agents: ${unmatched}`);
+    }
+
+    // Enforce minimum agent count
+    const fallbackByComplexity = agentSettings.fallbackByComplexity ?? { simple: 0, medium: 2, high: 4 };
+    const minAdditional = fallbackByComplexity[detectedComplexity] ?? 5;
+    if (orchSelected.length < minAdditional && nonMandatory.length > 0) {
+      const remaining = nonMandatory.filter(a => !orchSelected.includes(a));
+      const topUpCount = Math.min(minAdditional - orchSelected.length, remaining.length);
+      if (topUpCount > 0) {
+        const shuffled = [...remaining].sort(() => Math.random() - 0.5);
+        const topUp = shuffled.slice(0, topUpCount);
+        orchSelected = [...orchSelected, ...topUp];
+        logDebug(HOOK, `Topped up ${topUpCount} agents to meet ${detectedComplexity} minimum: ${topUp.map(a => a.name)}`);
+      }
+    }
+
+    const selectedAgents = [...mandatoryAgents, ...orchSelected];
+    logInfo(HOOK, `Final selection: ${selectedAgents.length} agents (${mandatoryAgents.length} mandatory + ${orchSelected.length} additional)`);
+    return { selectedAgents, mandatoryNames, detectedComplexity };
+  }
+
+  // Legacy mode: all enabled agents
+  logInfo(HOOK, "Running in legacy mode (all enabled agents)");
+  detectedComplexity = "medium";
+  mandatoryNames = resolveMandatoryAgents(mandatoryConfig, detectedComplexity);
+  return { selectedAgents: enabledAgents, mandatoryNames, detectedComplexity };
+}

package/dist/templates/cc-native/_cc-native/lib-ts/aggregate-agents.ts

@@ -1,18 +1,12 @@
 /**
  * Agent frontmatter parser — discovers and loads agent configs from markdown files.
  * See cc-native-plan-review-spec.md §4.14
- *
- * NOTE: This file intentionally stays in lib-ts/ rather than plan-review/lib/.
- * Both settings.ts (shared cc-native infra) and plan-questions.ts (plan-review) import it.
- * Moving it to plan-review/ would create a forbidden backward dependency: lib-ts → plan-review.
- * Do not move this file without first moving settings.ts out of lib-ts/.
  */
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-
+import { logDebug, logInfo, logWarn } from "../../_core/lib-ts/runtime/logger.js";
 import type { AgentConfig } from "./types.js";
-import { logDebug, logInfo, logWarn } from "../../_shared/lib-ts/base/logger.js";
 
 /**
  * Extract simple YAML frontmatter from markdown content.
@@ -53,7 +47,7 @@ export function extractFrontmatter(
       value = value
         .slice(1, -1)
         .split(",")
-        .map((s) => s.trim().replaceAll(/^["']|["']$/g, ""))
+        .map((s) => s.trim().replace(/^["']|["']$/g, ""))
         .filter(Boolean);
     }
     // Handle booleans
@@ -97,13 +91,11 @@ export function extractBody(content: string): string {
  * Discover and load all agent configs from a directory of markdown files.
  * Skips the plan-orchestrator agent. Defaults categories to ["code"].
  *
- * @param agentsDir - Path to agents directory. Callers must pass an explicit path.
- *   Known call sites: settings.ts → plan-review/agents/plan-review,
- *   plan-questions.ts → plan-review/agents/plan-questions
+ * @param agentsDir - Path to agents directory (default: _cc-native/agents/)
  * @returns Array of AgentConfig objects
  */
 export function aggregateAgents(agentsDir?: string): AgentConfig[] {
-  const dir = agentsDir ?? path.join("_cc-native", "plan-review", "agents");
+  const dir = agentsDir ?? path.join("_cc-native", "agents");
 
   if (!fs.existsSync(dir)) {
     logWarn("aggregate", `Agents directory not found: ${dir}`);
@@ -122,8 +114,8 @@ export function aggregateAgents(agentsDir?: string): AgentConfig[] {
     let content: string;
     try {
       content = fs.readFileSync(filePath, "utf-8");
-    } catch (error: unknown) {
-      logWarn("aggregate", `Failed to read ${file}: ${error}`);
+    } catch (e: unknown) {
+      logWarn("aggregate", `Failed to read ${file}: ${e}`);
       continue;
     }