aiwcli 0.15.5 → 0.17.0

package/dist/templates/cc-native/_cc-native/plan-review/lib/__tests__/preflight.test.ts

@@ -0,0 +1,344 @@
+/**
+ * Tests for preflight health checks.
+ * Tests pure functions (collectPreflightChecks, buildPreflightReport) directly.
+ * Tests classifyError from shared preflight module directly.
+ * Slim integration tests for runPreflight mock only checkProviderModel (network boundary).
+ */
+
+import { describe, it, expect, mock, beforeEach } from "bun:test";
+
+import type { ModelsConfig, PreflightCheckResult, PreflightReport } from "../../../lib-ts/types.js";
+
+// ---------------------------------------------------------------------------
+// Mock logger for noise suppression only (no assertions on logger calls)
+// ---------------------------------------------------------------------------
+
+mock.module("../../../../_core/lib-ts/runtime/logger.js", () => ({
+  hookLog() {},
+  logDebug() {},
+  logInfo() {},
+  logWarn() {},
+  logError() {},
+  logBlocking() {},
+  logDiagnostic() {},
+  logHookError() {},
+  setSessionId() {},
+  setContextPath() {},
+  getContextPath: () => null,
+}));
+
+// ---------------------------------------------------------------------------
+// Import pure functions under test (no mocks needed)
+// ---------------------------------------------------------------------------
+
+const { collectPreflightChecks, buildPreflightReport } = await import("../preflight.js");
+const { classifyError } = await import("../../../../_core/lib-ts/runtime/preflight.js");
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeModelsConfig(providers: Record<string, { enabled: boolean; models: string[] }>): ModelsConfig {
+  return { providers };
+}
+
+// ---------------------------------------------------------------------------
+// collectPreflightChecks — pure, zero mocks
+// ---------------------------------------------------------------------------
+
+describe("preflight", () => {
+describe("collectPreflightChecks", () => {
+  const knownProviders = new Set(["claude", "codex"]);
+
+  it("collects enabled providers with known names", () => {
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: ["sonnet"] },
+      codex: { enabled: true, models: ["codex-mini-latest"] },
+    });
+
+    const { checks, skippedProviders } = collectPreflightChecks(config, knownProviders);
+
+    expect(checks).toEqual([
+      { provider: "claude", model: "sonnet" },
+      { provider: "codex", model: "codex-mini-latest" },
+    ]);
+    expect(skippedProviders).toEqual([]);
+  });
+
+  it("skips disabled providers", () => {
+    const config = makeModelsConfig({
+      claude: { enabled: false, models: ["sonnet"] },
+      codex: { enabled: true, models: ["codex-mini-latest"] },
+    });
+
+    const { checks } = collectPreflightChecks(config, knownProviders);
+
+    expect(checks).toEqual([{ provider: "codex", model: "codex-mini-latest" }]);
+  });
+
+  it("skips providers with empty model lists", () => {
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: [] },
+    });
+
+    const { checks } = collectPreflightChecks(config, knownProviders);
+
+    expect(checks).toEqual([]);
+  });
+
+  it("reports unknown providers in skippedProviders", () => {
+    const config = makeModelsConfig({
+      unknown_provider: { enabled: true, models: ["some-model"] },
+    });
+
+    const { checks, skippedProviders } = collectPreflightChecks(config, knownProviders);
+
+    expect(checks).toEqual([]);
+    expect(skippedProviders).toEqual(["unknown_provider"]);
+  });
+
+  it("deduplicates same provider:model combo", () => {
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: ["sonnet", "sonnet"] },
+    });
+
+    const { checks } = collectPreflightChecks(config, knownProviders);
+
+    expect(checks).toEqual([{ provider: "claude", model: "sonnet" }]);
+  });
+
+  it("collects multiple models per provider", () => {
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: ["sonnet", "opus"] },
+    });
+
+    const { checks } = collectPreflightChecks(config, knownProviders);
+
+    expect(checks).toEqual([
+      { provider: "claude", model: "sonnet" },
+      { provider: "claude", model: "opus" },
+    ]);
+  });
+
+  it("returns empty checks when no providers are enabled", () => {
+    const config = makeModelsConfig({
+      claude: { enabled: false, models: ["sonnet"] },
+    });
+
+    const { checks, skippedProviders } = collectPreflightChecks(config, knownProviders);
+
+    expect(checks).toEqual([]);
+    expect(skippedProviders).toEqual([]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildPreflightReport — pure, zero mocks
+// ---------------------------------------------------------------------------
+
+describe("buildPreflightReport", () => {
+  it("builds available map from passing results", () => {
+    const results = [
+      { provider: "claude", model: "sonnet", available: true, latencyMs: 50 },
+      { provider: "codex", model: "codex-mini-latest", available: true, latencyMs: 30 },
+    ];
+
+    const report = buildPreflightReport(results, 100);
+
+    expect(report.allFailed).toBe(false);
+    expect(report.available.size).toBe(2);
+    expect(report.available.get("claude")?.has("sonnet")).toBe(true);
+    expect(report.available.get("codex")?.has("codex-mini-latest")).toBe(true);
+    expect(report.totalMs).toBe(100);
+  });
+
+  it("reports allFailed when all results fail", () => {
+    const results = [
+      { provider: "claude", model: "sonnet", available: false, error: "Auth failed", latencyMs: 10 },
+      { provider: "codex", model: "codex-mini", available: false, error: "Timeout", latencyMs: 15_000 },
+    ];
+
+    const report = buildPreflightReport(results, 15_000);
+
+    expect(report.allFailed).toBe(true);
+    expect(report.available.size).toBe(0);
+  });
+
+  it("reports allFailed=true for empty results", () => {
+    const report = buildPreflightReport([], 5);
+
+    expect(report.allFailed).toBe(true);
+    expect(report.available.size).toBe(0);
+    expect(report.checks).toEqual([]);
+  });
+
+  it("groups multiple models under same provider", () => {
+    const results = [
+      { provider: "claude", model: "sonnet", available: true, latencyMs: 50 },
+      { provider: "claude", model: "opus", available: true, latencyMs: 80 },
+    ];
+
+    const report = buildPreflightReport(results, 80);
+
+    expect(report.available.get("claude")?.size).toBe(2);
+    expect(report.available.get("claude")?.has("sonnet")).toBe(true);
+    expect(report.available.get("claude")?.has("opus")).toBe(true);
+  });
+
+  it("excludes failed models from available map", () => {
+    const results = [
+      { provider: "claude", model: "sonnet", available: true, latencyMs: 50 },
+      { provider: "claude", model: "opus", available: false, error: "Rate limited", latencyMs: 10 },
+    ];
+
+    const report = buildPreflightReport(results, 50);
+
+    expect(report.allFailed).toBe(false);
+    expect(report.available.get("claude")?.has("sonnet")).toBe(true);
+    expect(report.available.get("claude")?.has("opus")).toBe(false);
+  });
+
+  it("preserves check results in output", () => {
+    const results = [
+      { provider: "claude", model: "sonnet", available: true, latencyMs: 42 },
+    ];
+
+    const report = buildPreflightReport(results, 42);
+
+    expect(report.checks.length).toBe(1);
+    expect(report.checks[0]!.provider).toBe("claude");
+    expect(report.checks[0]!.model).toBe("sonnet");
+    expect(report.checks[0]!.available).toBe(true);
+    expect(report.checks[0]!.latencyMs).toBe(42);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// classifyError — pure, zero mocks (from shared _core/lib-ts/runtime/preflight.ts)
+// ---------------------------------------------------------------------------
+
+describe("classifyError", () => {
+  it("classifies timeout (killed + SIGTERM)", () => {
+    expect(classifyError("", null, true, "SIGTERM")).toBe("Preflight timed out");
+  });
+
+  it("classifies timeout (killed without signal)", () => {
+    expect(classifyError("", null, true, null)).toBe("Preflight timed out");
+  });
+
+  it("classifies model not found", () => {
+    expect(classifyError("model not found", 1, false, null)).toBe("Model not available for this account");
+  });
+
+  it("classifies not available", () => {
+    expect(classifyError("not available for your plan", 1, false, null)).toBe("Model not available for this account");
+  });
+
+  it("classifies rate limit by text", () => {
+    expect(classifyError("rate limit exceeded", 1, false, null)).toBe("Rate limited");
+  });
+
+  it("classifies rate limit by 429", () => {
+    expect(classifyError("error 429", 1, false, null)).toBe("Rate limited");
+  });
+
+  it("classifies auth errors", () => {
+    expect(classifyError("invalid api key", 1, false, null)).toBe("Authentication failed");
+  });
+
+  it("classifies 401 as auth", () => {
+    expect(classifyError("HTTP 401 Unauthorized", 1, false, null)).toBe("Authentication failed");
+  });
+
+  it("classifies quota errors", () => {
+    expect(classifyError("billing quota exceeded", 1, false, null)).toBe("Quota/billing issue");
+  });
+
+  it("falls back to exit code for unknown errors", () => {
+    expect(classifyError("something unexpected", 42, false, null)).toBe("Exit code 42");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// runPreflight — slim integration (mock only checkProviderModel)
+// ---------------------------------------------------------------------------
+
+describe("runPreflight", () => {
+  // Mock the network boundary: checkProviderModel and subprocess-utils
+  const mockCheckProviderModel = mock(
+    async (provider: string, model: string) =>
+      ({ provider, model, available: true, latencyMs: 10 }) as PreflightCheckResult,
+  );
+
+  const mockFindExecutable = mock(() => "/usr/bin/mock-cli" as string | null);
+
+  // Re-mock the modules to inject our mock for integration tests
+  mock.module("../../../../_core/lib-ts/runtime/preflight.js", () => ({
+    checkProviderModel: mockCheckProviderModel,
+    classifyError,
+  }));
+
+  mock.module("../../../../_core/lib-ts/runtime/subprocess-utils.js", () => ({
+    findExecutable: mockFindExecutable,
+    execFileAsync: mock(() => Promise.resolve({ stdout: "ok", stderr: "", exitCode: 0, killed: false, signal: null })),
+    isInternalCall: () => false,
+    getInternalSubprocessEnv: () => ({}),
+    normalizePathForCli: (p: string) => p,
+    shellQuoteWin: (arg: string) => arg,
+    isExecSyncError: () => false,
+  }));
+
+  // Re-import to pick up the mocked checkProviderModel
+  let runPreflight: (config: ModelsConfig, timeoutMs?: number) => Promise<PreflightReport>;
+
+  beforeEach(async () => {
+    mockCheckProviderModel.mockReset();
+    mockCheckProviderModel.mockImplementation(
+      async (provider: string, model: string) =>
+        ({ provider, model, available: true, latencyMs: 10 }) as PreflightCheckResult,
+    );
+    // Force fresh import to pick up mocks
+    const mod = await import("../preflight.js");
+    runPreflight = mod.runPreflight;
+  });
+
+  it("returns available report when checks pass", async () => {
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: ["sonnet"] },
+      codex: { enabled: true, models: ["codex-mini-latest"] },
+    });
+
+    const report = await runPreflight(config);
+
+    expect(report.allFailed).toBe(false);
+    expect(report.available.size).toBe(2);
+  });
+
+  it("reports allFailed when all checks fail", async () => {
+    mockCheckProviderModel.mockImplementation(
+      async (provider: string, model: string) =>
+        ({ provider, model, available: false, latencyMs: 10, error: "Auth failed" }) as PreflightCheckResult,
+    );
+
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: ["sonnet"] },
+    });
+
+    const report = await runPreflight(config);
+
+    expect(report.allFailed).toBe(true);
+    expect(report.available.size).toBe(0);
+  });
+
+  it("returns empty checks when no providers enabled", async () => {
+    const config = makeModelsConfig({
+      claude: { enabled: false, models: ["sonnet"] },
+    });
+
+    const report = await runPreflight(config);
+
+    expect(report.allFailed).toBe(true);
+    expect(report.checks.length).toBe(0);
+  });
+});
+});

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

@@ -3,8 +3,8 @@
  * Extracted from cc-native-plan-review.ts.
  */
 
-import { logDebug, logInfo, logWarn } from "../../../_shared/lib-ts/base/logger.js";
-import { findExecutable } from "../../../_shared/lib-ts/base/subprocess-utils.js";
+import { logDebug, logInfo, logWarn } from "../../../_core/lib-ts/runtime/logger.js";
+import { findExecutable } from "../../../_core/lib-ts/runtime/subprocess-utils.js";
 import type {
   AgentConfig,
   AgentReviewSettings,
@@ -51,22 +51,21 @@ export function resolveMandatoryAgents(
 /** Provider priority order: codex first (cheaper/faster), claude as fallback */
 const PROVIDER_PRIORITY = ["codex", "claude"];
 
-/**
- * Assign providers and models to agents.
- * When preflightAvailable is provided, filters to only models that passed preflight.
- * Providers are ordered by PROVIDER_PRIORITY (codex first, claude fallback).
- * All agents get the first available provider; random model within that provider.
- */
-export function assignModelsToAgents(
-  agents: AgentConfig[],
+// ---------------------------------------------------------------------------
+// Pure Provider Resolution (extracted for direct testing)
+// ---------------------------------------------------------------------------
+
+/** @internal */
+export function resolveEnabledProviders(
   modelsConfig: ModelsConfig,
+  isCliAvailable: (cliName: string) => boolean,
   preflightAvailable?: Map<string, Set<string>>,
-): AgentConfig[] {
-  let enabledProviders = Object.entries(modelsConfig.providers)
+): Array<[string, { enabled: boolean; models: string[] }]> {
+  const result = 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);
+      const found = isCliAvailable(cliName);
       if (!found) {
         logWarn(HOOK, `Provider '${name}' enabled but CLI '${cliName}' not found on PATH — skipping`);
         return false;
@@ -93,12 +92,35 @@ export function assignModelsToAgents(
     .filter((entry): entry is [string, { enabled: boolean; models: string[] }] => entry !== null);
 
   // Sort by provider priority (codex first)
-  enabledProviders.sort((a, b) => {
+  result.sort((a, b) => {
     const aIdx = PROVIDER_PRIORITY.indexOf(a[0]);
     const bIdx = PROVIDER_PRIORITY.indexOf(b[0]);
     return (aIdx === -1 ? 999 : aIdx) - (bIdx === -1 ? 999 : bIdx);
   });
 
+  return result;
+}
+
+/**
+ * Assign providers and models to agents.
+ * When preflightAvailable is provided, filters to only models that passed preflight.
+ * Providers are ordered by PROVIDER_PRIORITY (codex first, claude fallback).
+ * All agents get the first available provider; random model within that provider.
+ */
+export function assignModelsToAgents(
+  agents: AgentConfig[],
+  modelsConfig: ModelsConfig,
+  preflightAvailable?: Map<string, Set<string>>,
+  options?: {
+    isCliAvailable?: (name: string) => boolean;
+    randomFn?: () => number;
+  },
+): AgentConfig[] {
+  const isCliAvailable = options?.isCliAvailable ?? ((name: string) => Boolean(findExecutable(name)));
+  const randomFn = options?.randomFn ?? Math.random;
+
+  const enabledProviders = resolveEnabledProviders(modelsConfig, isCliAvailable, preflightAvailable);
+
   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" }));
@@ -109,9 +131,9 @@ export function assignModelsToAgents(
   logInfo(HOOK, `Using provider: ${providerName} (models: ${providerConfig.models.join(", ")})`);
 
   return agents.map(agent => {
-    const modelIdx = Math.floor(Math.random() * providerConfig.models.length);
+    const modelIdx = Math.floor(randomFn() * providerConfig.models.length);
     const model = providerConfig.models[modelIdx] ?? providerConfig.models[0] ?? agent.model;
-    return { ...agent, provider: providerName, model };
+    return { ...agent, provider: providerName, model, reasoning_effort: providerConfig.reasoning_effort };
   });
 }
 

package/dist/templates/cc-native/_cc-native/plan-review/lib/preflight.ts

@@ -3,18 +3,18 @@
  * Validates provider+model combos work before committing agents to them.
  * Runs minimal "ping" requests in parallel per unique provider:model combo.
  *
- * Uses shared checkProviderModel() from _shared/lib-ts/base/preflight.ts.
+ * Uses shared checkProviderModel() from _core/lib-ts/runtime/preflight.ts.
  * This module provides the batch orchestrator and provider registry specific
  * to the plan review pipeline.
  */
 
-import { preflightCommandConfig } from "../../../_shared/lib-ts/base/cli-args.js";
-import { logInfo, logWarn } from "../../../_shared/lib-ts/base/logger.js";
-import { checkProviderModel, type PreflightCommandConfig } from "../../../_shared/lib-ts/base/preflight.js";
+import { preflightCommandConfig } from "../../../_core/lib-ts/runtime/cli-args.js";
+import { logInfo, logWarn } from "../../../_core/lib-ts/runtime/logger.js";
+import { checkProviderModel, type PreflightCommandConfig } from "../../../_core/lib-ts/runtime/preflight.js";
 import type { ModelsConfig, PreflightCheckResult, PreflightReport } from "../../lib-ts/types.js";
 
 const HOOK = "preflight";
-const DEFAULT_TIMEOUT_MS = 15000;
+const DEFAULT_TIMEOUT_MS = 15_000;
 
 // ---------------------------------------------------------------------------
 // Provider Registry (built from centralized cli-args)
@@ -25,25 +25,25 @@ const PREFLIGHT_COMMANDS: Record<string, PreflightCommandConfig> = {
   codex:  preflightCommandConfig("codex"),
 };
 
+export const KNOWN_PROVIDERS = new Set(Object.keys(PREFLIGHT_COMMANDS));
+
 // ---------------------------------------------------------------------------
-// Run All Checks
+// Pure Functions (extracted for direct testing)
 // ---------------------------------------------------------------------------
 
-export async function runPreflight(
+/** @internal */
+export function collectPreflightChecks(
   modelsConfig: ModelsConfig,
-  timeoutMs?: number,
-): Promise<PreflightReport> {
-  const effectiveTimeout = timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const start = Date.now();
-
-  // Collect unique provider:model combos from enabled providers
+  knownProviders: Set<string>,
+): { checks: Array<{ provider: string; model: string }>; skippedProviders: string[] } {
   const checks: Array<{ provider: string; model: string }> = [];
   const seen = new Set<string>();
+  const skippedProviders: string[] = [];
 
   for (const [provider, config] of Object.entries(modelsConfig.providers)) {
     if (!config.enabled || config.models.length === 0) continue;
-    if (!PREFLIGHT_COMMANDS[provider]) {
-      logWarn(HOOK, `No preflight command for provider '${provider}', skipping`);
+    if (!knownProviders.has(provider)) {
+      skippedProviders.push(provider);
       continue;
     }
     for (const model of config.models) {
@@ -55,6 +55,45 @@ export async function runPreflight(
     }
   }
 
+  return { checks, skippedProviders };
+}
+
+/** @internal */
+export function buildPreflightReport(
+  results: Array<{ provider: string; model: string; available: boolean; error?: string; latencyMs?: number }>,
+  totalMs: number,
+): PreflightReport {
+  const available = new Map<string, Set<string>>();
+  for (const r of results) {
+    if (r.available) {
+      if (!available.has(r.provider)) available.set(r.provider, new Set());
+      available.get(r.provider)!.add(r.model);
+    }
+  }
+
+  const allFailed = available.size === 0;
+
+  return { checks: results as PreflightCheckResult[], available, allFailed, totalMs };
+}
+
+// ---------------------------------------------------------------------------
+// Run All Checks
+// ---------------------------------------------------------------------------
+
+export async function runPreflight(
+  modelsConfig: ModelsConfig,
+  timeoutMs?: number,
+): Promise<PreflightReport> {
+  const effectiveTimeout = timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const start = Date.now();
+
+  // Collect unique provider:model combos from enabled providers
+  const { checks, skippedProviders } = collectPreflightChecks(modelsConfig, KNOWN_PROVIDERS);
+
+  for (const provider of skippedProviders) {
+    logWarn(HOOK, `No preflight command for provider '${provider}', skipping`);
+  }
+
   if (checks.length === 0) {
     logWarn(HOOK, "No provider:model combos to check");
     return { checks: [], available: new Map(), allFailed: true, totalMs: Date.now() - start };
@@ -69,17 +108,8 @@ export async function runPreflight(
     ),
   );
 
-  // Build available map
-  const available = new Map<string, Set<string>>();
-  for (const r of results) {
-    if (r.available) {
-      if (!available.has(r.provider)) available.set(r.provider, new Set());
-      available.get(r.provider)!.add(r.model);
-    }
-  }
-
-  const allFailed = available.size === 0;
   const totalMs = Date.now() - start;
+  const report = buildPreflightReport(results, totalMs);
 
   // Log summary
   const passed = results.filter(r => r.available).length;
@@ -92,5 +122,5 @@ export async function runPreflight(
     }
   }
 
-  return { checks: results, available, allFailed, totalMs };
+  return report;
 }