aiwcli 0.15.5 → 0.17.0

package/dist/templates/cc-native/_cc-native/lib-ts/__tests__/orchestrator-agent.test.ts

@@ -0,0 +1,288 @@
+/**
+ * Integration test for OrchestratorClaudeAgent via runOrchestrator().
+ * Tests the migration from direct execFileAsync to BaseCliAgent framework.
+ *
+ * Run: bun test .aiwcli/_cc-native/lib-ts/__tests__/orchestrator-agent.test.ts
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import type { AgentConfig, OrchestratorConfig, OrchestratorResult } from "../types.js";
+
+// Mock subprocess-utils to avoid actual CLI invocations
+vi.mock("../../../_core/lib-ts/runtime/subprocess-utils.js", () => ({
+  findExecutable: vi.fn(),
+  execFileAsync: vi.fn(),
+  getInternalSubprocessEnv: vi.fn(() => ({})),
+  shellQuoteWin: vi.fn((s: string) => s),
+}));
+
+// Mock logger to suppress output
+vi.mock("../../../_core/lib-ts/runtime/logger.js", () => ({
+  logDebug: vi.fn(),
+  logInfo: vi.fn(),
+  logWarn: vi.fn(),
+  logError: vi.fn(),
+}));
+
+const FAKE_PLAN = `# Add User Authentication
+
+## Steps
+1. Add JWT middleware
+2. Create login/register endpoints
+3. Add password hashing with bcrypt
+4. Write integration tests
+
+## Files
+- src/auth/middleware.ts
+- src/auth/routes.ts
+- src/auth/hash.ts
+`;
+
+const FAKE_AGENTS: AgentConfig[] = [
+  {
+    name: "security-reviewer",
+    model: "claude-sonnet-4-5-20250929",
+    provider: "claude",
+    focus: "security",
+    enabled: true,
+    categories: ["code", "security"],
+    description: "Reviews security concerns",
+    system_prompt: "You are a security reviewer.",
+  },
+  {
+    name: "architecture-reviewer",
+    model: "claude-sonnet-4-5-20250929",
+    provider: "claude",
+    focus: "architecture",
+    enabled: true,
+    categories: ["code", "infrastructure"],
+    description: "Reviews architecture decisions",
+    system_prompt: "You are an architecture reviewer.",
+  },
+  {
+    name: "testing-reviewer",
+    model: "claude-sonnet-4-5-20250929",
+    provider: "claude",
+    focus: "testing",
+    enabled: true,
+    categories: ["code"],
+    description: "Reviews test coverage",
+    system_prompt: "You are a testing reviewer.",
+  },
+];
+
+const FAKE_CONFIG: OrchestratorConfig = {
+  enabled: true,
+  model: "claude-sonnet-4-5-20250929",
+  timeout: 60,
+};
+
+const FAKE_SETTINGS: Record<string, unknown> = {
+  agentSelection: {
+    simple: { min: 1, max: 2 },
+    medium: { min: 3, max: 5 },
+    high: { min: 5, max: 8 },
+    fallbackCount: 2,
+  },
+  complexityCategories: ["code", "infrastructure", "documentation"],
+};
+
+describe("OrchestratorClaudeAgent via runOrchestrator", () => {
+  let findExecutable: ReturnType<typeof vi.fn>;
+  let execFileAsync: ReturnType<typeof vi.fn>;
+
+  beforeEach(async () => {
+    const subproc = await import("../../../_core/lib-ts/runtime/subprocess-utils.js");
+    findExecutable = subproc.findExecutable as ReturnType<typeof vi.fn>;
+    execFileAsync = subproc.execFileAsync as ReturnType<typeof vi.fn>;
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("returns fallback when claude CLI not found", async () => {
+    findExecutable.mockReturnValue(null);
+
+    const { runOrchestrator } = await import("../orchestrator.js");
+    const result = await runOrchestrator(FAKE_PLAN, FAKE_AGENTS, FAKE_CONFIG, FAKE_SETTINGS);
+
+    expect(result.complexity).toBe("medium");
+    expect(result.category).toBe("code");
+    expect(result.selected_agents).toHaveLength(2); // fallbackCount
+    expect(result.error).toBeDefined();
+  });
+
+  it("parses valid orchestrator output", async () => {
+    findExecutable.mockReturnValue("/usr/bin/claude");
+
+    const mockOutput = JSON.stringify({
+      structured_output: {
+        complexity: "high",
+        category: "code",
+        selectedAgents: ["security-reviewer", "architecture-reviewer", "testing-reviewer"],
+        reasoning: "Authentication involves security-sensitive operations requiring thorough review.",
+      },
+    });
+
+    execFileAsync.mockResolvedValue({
+      stdout: mockOutput,
+      stderr: "",
+      exitCode: 0,
+      signal: null,
+      killed: false,
+    });
+
+    const { runOrchestrator } = await import("../orchestrator.js");
+    const result = await runOrchestrator(FAKE_PLAN, FAKE_AGENTS, FAKE_CONFIG, FAKE_SETTINGS);
+
+    expect(result.complexity).toBe("high");
+    expect(result.category).toBe("code");
+    expect(result.selected_agents).toEqual(["security-reviewer", "architecture-reviewer", "testing-reviewer"]);
+    expect(result.reasoning).toContain("security-sensitive");
+    expect(result.error).toBeUndefined();
+  });
+
+  it("returns fallback on timeout", async () => {
+    findExecutable.mockReturnValue("/usr/bin/claude");
+
+    execFileAsync.mockResolvedValue({
+      stdout: "",
+      stderr: "",
+      exitCode: null,
+      signal: "SIGTERM",
+      killed: true,
+    });
+
+    const { runOrchestrator } = await import("../orchestrator.js");
+    const result = await runOrchestrator(FAKE_PLAN, FAKE_AGENTS, FAKE_CONFIG, FAKE_SETTINGS);
+
+    expect(result.complexity).toBe("medium");
+    expect(result.error).toBeDefined();
+  });
+
+  it("returns fallback on non-zero exit with no output", async () => {
+    findExecutable.mockReturnValue("/usr/bin/claude");
+
+    execFileAsync.mockResolvedValue({
+      stdout: "",
+      stderr: "",
+      exitCode: 1,
+      signal: null,
+      killed: false,
+    });
+
+    const { runOrchestrator } = await import("../orchestrator.js");
+    const result = await runOrchestrator(FAKE_PLAN, FAKE_AGENTS, FAKE_CONFIG, FAKE_SETTINGS);
+
+    expect(result.complexity).toBe("medium");
+    expect(result.error).toBeDefined();
+  });
+
+  it("validates complexity enum — invalid falls back to medium", async () => {
+    findExecutable.mockReturnValue("/usr/bin/claude");
+
+    const mockOutput = JSON.stringify({
+      structured_output: {
+        complexity: "extreme", // invalid
+        category: "code",
+        selectedAgents: ["security-reviewer"],
+        reasoning: "Test",
+      },
+    });
+
+    execFileAsync.mockResolvedValue({
+      stdout: mockOutput,
+      stderr: "",
+      exitCode: 0,
+      signal: null,
+      killed: false,
+    });
+
+    const { runOrchestrator } = await import("../orchestrator.js");
+    const result = await runOrchestrator(FAKE_PLAN, FAKE_AGENTS, FAKE_CONFIG, FAKE_SETTINGS);
+
+    expect(result.complexity).toBe("medium"); // fallback
+  });
+
+  it("validates category — invalid falls back to code", async () => {
+    findExecutable.mockReturnValue("/usr/bin/claude");
+
+    const mockOutput = JSON.stringify({
+      structured_output: {
+        complexity: "simple",
+        category: "quantum-physics", // not in categories list
+        selectedAgents: [],
+        reasoning: "Test",
+      },
+    });
+
+    execFileAsync.mockResolvedValue({
+      stdout: mockOutput,
+      stderr: "",
+      exitCode: 0,
+      signal: null,
+      killed: false,
+    });
+
+    const { runOrchestrator } = await import("../orchestrator.js");
+    const result = await runOrchestrator(FAKE_PLAN, FAKE_AGENTS, FAKE_CONFIG, FAKE_SETTINGS);
+
+    expect(result.category).toBe("code"); // fallback
+  });
+
+  it("excludes mandatory agents from selection pool", async () => {
+    findExecutable.mockReturnValue("/usr/bin/claude");
+
+    const mockOutput = JSON.stringify({
+      structured_output: {
+        complexity: "medium",
+        category: "code",
+        selectedAgents: ["testing-reviewer"],
+        reasoning: "Only non-mandatory agents selected",
+      },
+    });
+
+    execFileAsync.mockResolvedValue({
+      stdout: mockOutput,
+      stderr: "",
+      exitCode: 0,
+      signal: null,
+      killed: false,
+    });
+
+    const mandatory = new Set(["security-reviewer"]);
+    const { runOrchestrator } = await import("../orchestrator.js");
+    const result = await runOrchestrator(FAKE_PLAN, FAKE_AGENTS, FAKE_CONFIG, FAKE_SETTINGS, mandatory);
+
+    expect(result.selected_agents).toEqual(["testing-reviewer"]);
+  });
+
+  it("passes correct CLI args to execFileAsync", async () => {
+    findExecutable.mockReturnValue("/usr/bin/claude");
+
+    execFileAsync.mockResolvedValue({
+      stdout: JSON.stringify({ structured_output: { complexity: "simple", category: "code", selectedAgents: [], reasoning: "test" } }),
+      stderr: "",
+      exitCode: 0,
+      signal: null,
+      killed: false,
+    });
+
+    const { runOrchestrator } = await import("../orchestrator.js");
+    await runOrchestrator(FAKE_PLAN, FAKE_AGENTS, FAKE_CONFIG, FAKE_SETTINGS);
+
+    expect(execFileAsync).toHaveBeenCalledOnce();
+    const [cliPath, args, opts] = execFileAsync.mock.calls[0];
+
+    expect(cliPath).toBe("/usr/bin/claude");
+    expect(args).toContain("--model");
+    expect(args).toContain(FAKE_CONFIG.model);
+    expect(args).toContain("--output-format");
+    expect(args).toContain("json");
+    expect(args).toContain("--json-schema");
+    expect(args).toContain("--system-prompt");
+    expect(args).toContain("-p");
+    expect(opts.timeout).toBe(FAKE_CONFIG.timeout * 1000);
+  });
+});

package/dist/templates/cc-native/_cc-native/lib-ts/__tests__/orchestrator.test.ts

@@ -0,0 +1,48 @@
+import { expect } from "chai";
+import { buildOrchestratorSchema } from "../orchestrator.js";
+
+describe("orchestrator", () => {
+  describe("buildOrchestratorSchema", () => {
+    it("returns valid JSON schema object", () => {
+      const schema = buildOrchestratorSchema(
+        ["agent-a", "agent-b"],
+        ["code", "documentation"],
+      );
+      expect(schema.type).to.equal("object");
+      expect(schema.required).to.include("complexity");
+      expect(schema.required).to.include("selectedAgents");
+    });
+
+    it("constrains agent names with enum", () => {
+      const schema = buildOrchestratorSchema(
+        ["alpha", "beta"],
+        ["code"],
+      );
+      const props = schema.properties as any;
+      expect(props.selectedAgents.items.enum).to.deep.equal(["alpha", "beta"]);
+    });
+
+    it("omits enum when agent list is empty", () => {
+      const schema = buildOrchestratorSchema([], ["code"]);
+      const props = schema.properties as any;
+      expect(props.selectedAgents.items).to.not.have.property("enum");
+    });
+
+    it("constrains complexity to simple/medium/high", () => {
+      const schema = buildOrchestratorSchema(["a"], ["code"]);
+      const props = schema.properties as any;
+      expect(props.complexity.enum).to.deep.equal(["simple", "medium", "high"]);
+    });
+
+    it("includes categories in category enum", () => {
+      const schema = buildOrchestratorSchema(["a"], ["code", "life", "business"]);
+      const props = schema.properties as any;
+      expect(props.category.enum).to.deep.equal(["code", "life", "business"]);
+    });
+
+    it("disallows additional properties", () => {
+      const schema = buildOrchestratorSchema(["a"], ["code"]);
+      expect(schema.additionalProperties).to.equal(false);
+    });
+  });
+});

package/dist/templates/cc-native/_cc-native/lib-ts/__tests__/reviewers.test.ts

@@ -0,0 +1,32 @@
+import { expect } from "chai";
+import { makeResult } from "../reviewers/types.js";
+import type { ReviewData, Verdict } from "../types.js";
+
+describe("reviewers", () => {
+  describe("makeResult", () => {
+    it("creates a ReviewerResult with all fields", () => {
+      const data: ReviewData = {
+        verdict: "pass",
+        summary: "All good",
+        summary_source: "reviewer",
+        issues: [],
+        missing_sections: [],
+        questions: [],
+      };
+      const result = makeResult("test-reviewer", true, "pass", data, '{"verdict":"pass"}', "");
+      expect(result.name).to.equal("test-reviewer");
+      expect(result.ok).to.be.true;
+      expect(result.verdict).to.equal("pass");
+      expect(result.data).to.deep.equal(data);
+      expect(result.raw).to.equal('{"verdict":"pass"}');
+      expect(result.err).to.equal("");
+    });
+
+    it("handles error case", () => {
+      const result = makeResult("failing-reviewer", false, "error", {}, "", "Connection timeout");
+      expect(result.ok).to.be.false;
+      expect(result.verdict).to.equal("error");
+      expect(result.err).to.equal("Connection timeout");
+    });
+  });
+});

package/dist/templates/cc-native/_cc-native/lib-ts/__tests__/state.test.ts

@@ -0,0 +1,124 @@
+import { expect } from "chai";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import {
+  getStateFilePath,
+  getIterationState,
+  updateIterationState,
+  shouldContinueIterating,
+} from "../state.js";
+import { PLANS_DIR } from "../constants.js";
+import type { IterationState } from "../types.js";
+
+describe("state", () => {
+  describe("getStateFilePath", () => {
+    it("derives .state.json from .md path", () => {
+      const planPath = path.join(PLANS_DIR, "my-plan.md");
+      const result = getStateFilePath(planPath);
+      expect(result).to.match(/my-plan\.state\.json$/);
+    });
+
+    it("throws for path outside PLANS_DIR", () => {
+      expect(() => getStateFilePath(path.join(os.tmpdir(), "evil.md"))).to.throw();
+    });
+  });
+
+  describe("getIterationState", () => {
+    it("returns existing iteration state from state object", () => {
+      const existing: IterationState = {
+        current: 2,
+        max: 3,
+        complexity: "high",
+        history: [],
+      };
+      const state = { iteration: existing };
+      const result = getIterationState(state, "medium");
+      expect(result.current).to.equal(2);
+      expect(result.complexity).to.equal("high");
+    });
+
+    it("initializes new iteration state with default max", () => {
+      const result = getIterationState({}, "simple");
+      expect(result.current).to.equal(1);
+      expect(result.max).to.equal(1);
+      expect(result.complexity).to.equal("simple");
+      expect(result.history).to.deep.equal([]);
+    });
+
+    it("uses config overrides for max iterations", () => {
+      const config = { reviewIterations: { simple: 5 } };
+      const result = getIterationState({}, "simple", config);
+      expect(result.max).to.equal(5);
+    });
+
+    it("defaults to 1 for unknown complexity", () => {
+      const result = getIterationState({}, "unknown");
+      expect(result.max).to.equal(1);
+    });
+
+    it("uses high complexity default (2 iterations)", () => {
+      const result = getIterationState({}, "high");
+      expect(result.max).to.equal(2);
+    });
+  });
+
+  describe("updateIterationState", () => {
+    it("adds entry to history", () => {
+      const iteration: IterationState = {
+        current: 1,
+        max: 2,
+        complexity: "medium",
+        history: [],
+      };
+      const state: Record<string, unknown> = {};
+      const result = updateIterationState(state, iteration, "hash123", "pass");
+      expect(iteration.history).to.have.length(1);
+      expect(iteration.history[0]?.hash).to.equal("hash123");
+      expect(iteration.history[0]?.verdict).to.equal("pass");
+      expect(result.iteration).to.equal(iteration);
+    });
+  });
+
+  describe("shouldContinueIterating", () => {
+    it("returns false when at max iterations", () => {
+      const iteration: IterationState = {
+        current: 2,
+        max: 2,
+        complexity: "high",
+        history: [],
+      };
+      expect(shouldContinueIterating(iteration, "warn")).to.be.false;
+    });
+
+    it("returns false on pass with earlyExitOnAllPass (default)", () => {
+      const iteration: IterationState = {
+        current: 1,
+        max: 3,
+        complexity: "high",
+        history: [],
+      };
+      expect(shouldContinueIterating(iteration, "pass")).to.be.false;
+    });
+
+    it("returns true when below max and verdict is not pass", () => {
+      const iteration: IterationState = {
+        current: 1,
+        max: 3,
+        complexity: "high",
+        history: [],
+      };
+      expect(shouldContinueIterating(iteration, "warn")).to.be.true;
+    });
+
+    it("continues on pass when earlyExitOnAllPass is false", () => {
+      const iteration: IterationState = {
+        current: 1,
+        max: 3,
+        complexity: "high",
+        history: [],
+      };
+      expect(shouldContinueIterating(iteration, "pass", { earlyExitOnAllPass: false })).to.be.true;
+    });
+  });
+});

package/dist/templates/cc-native/_cc-native/lib-ts/__tests__/verdict.test.ts

@@ -0,0 +1,93 @@
+import { expect } from "chai";
+import { worstVerdict, computeReviewDecision } from "../verdict.js";
+import type { Verdict } from "../types.js";
+
+describe("verdict", () => {
+  describe("worstVerdict", () => {
+    it("returns pass for empty list", () => {
+      expect(worstVerdict([])).to.equal("pass");
+    });
+
+    it("returns pass for all pass", () => {
+      expect(worstVerdict(["pass", "pass", "pass"])).to.equal("pass");
+    });
+
+    it("returns warn when warn present", () => {
+      expect(worstVerdict(["pass", "warn", "pass"])).to.equal("warn");
+    });
+
+    it("returns fail when fail present", () => {
+      expect(worstVerdict(["pass", "warn", "fail"])).to.equal("fail");
+    });
+
+    it("maps skip to pass level (worst stays pass)", () => {
+      // skip has same priority as pass (0), so worst remains "pass"
+      expect(worstVerdict(["skip", "skip"])).to.equal("pass");
+    });
+
+    it("maps error to warn level", () => {
+      expect(worstVerdict(["pass", "error"])).to.equal("warn");
+    });
+
+    it("fail beats error", () => {
+      expect(worstVerdict(["error", "fail"])).to.equal("fail");
+    });
+
+    it("returns pass for single pass", () => {
+      expect(worstVerdict(["pass"])).to.equal("pass");
+    });
+  });
+
+  describe("computeReviewDecision", () => {
+    it("returns no_signal for empty verdicts", () => {
+      const result = computeReviewDecision([]);
+      expect(result.should_deny).to.be.false;
+      expect(result.reason).to.equal("no_signal");
+      expect(result.score).to.equal(0.0);
+    });
+
+    it("returns no_signal when all skip/error", () => {
+      const result = computeReviewDecision(["skip", "error", "skip"]);
+      expect(result.should_deny).to.be.false;
+      expect(result.reason).to.equal("no_signal");
+    });
+
+    it("denies when any fail present (fail veto)", () => {
+      const result = computeReviewDecision(["pass", "fail", "pass"]);
+      expect(result.should_deny).to.be.true;
+      expect(result.reason).to.equal("fail_veto");
+      expect(result.score).to.equal(1.0);
+    });
+
+    it("accepts all pass", () => {
+      const result = computeReviewDecision(["pass", "pass", "pass"]);
+      expect(result.should_deny).to.be.false;
+      expect(result.reason).to.equal("acceptable");
+      expect(result.score).to.equal(0.0);
+    });
+
+    it("accepts warns (warn does not block)", () => {
+      const result = computeReviewDecision(["warn", "warn", "pass"]);
+      expect(result.should_deny).to.be.false;
+      expect(result.reason).to.equal("acceptable");
+    });
+
+    it("computes correct warn ratio", () => {
+      const result = computeReviewDecision(["warn", "pass"]);
+      expect(result.score).to.equal(0.5);
+    });
+
+    it("excludes skip and error from signal", () => {
+      const result = computeReviewDecision(["pass", "skip", "error"]);
+      expect(result.should_deny).to.be.false;
+      expect(result.reason).to.equal("acceptable");
+      expect(result.score).to.equal(0.0);
+    });
+
+    it("single fail denies", () => {
+      const result = computeReviewDecision(["fail"]);
+      expect(result.should_deny).to.be.true;
+      expect(result.reason).to.equal("fail_veto");
+    });
+  });
+});