aiwcli 0.15.5 → 0.17.0

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

@@ -0,0 +1,107 @@
+/**
+ * Test helpers for cc-native lib-ts tests.
+ * Re-exports shared helpers and adds cc-native-specific factories.
+ */
+export {
+  createTempDir,
+  cleanupTempDir,
+  setProjectRoot,
+  captureStdout,
+  captureStderr,
+  createSampleState,
+  createSampleIndex,
+  createSampleHookInput,
+  createSampleTask,
+  writeStateJson,
+  writeIndexJson,
+  freezeTime,
+} from "../../../_core/lib-ts/__tests__/helpers.js";
+
+import type {
+  ReviewData,
+  ReviewerResult,
+  OrchestratorResult,
+  CombinedReviewResult,
+  AgentConfig,
+  PlanReviewConfig,
+  DisplaySettings,
+  Verdict,
+} from "../types.js";
+
+// ─── CC-Native Sample Data Factories ─────────────────────────────────────
+
+export function createSampleReviewData(
+  overrides?: Partial<ReviewData>,
+): ReviewData {
+  return {
+    verdict: "pass",
+    summary: "Plan looks good.",
+    summary_source: "reviewer",
+    issues: [],
+    missing_sections: [],
+    questions: [],
+    ...overrides,
+  };
+}
+
+export function createSampleReviewerResult(
+  overrides?: Partial<ReviewerResult>,
+): ReviewerResult {
+  return {
+    name: "test-reviewer",
+    ok: true,
+    verdict: "pass",
+    data: createSampleReviewData(),
+    raw: "{}",
+    err: "",
+    ...overrides,
+  };
+}
+
+export function createSampleOrchestratorResult(
+  overrides?: Partial<OrchestratorResult>,
+): OrchestratorResult {
+  return {
+    complexity: "medium",
+    category: "code",
+    selected_agents: ["agent-a", "agent-b"],
+    reasoning: "Plan involves moderate code changes.",
+    ...overrides,
+  };
+}
+
+export function createSampleCombinedResult(
+  overrides?: Partial<CombinedReviewResult>,
+): CombinedReviewResult {
+  return {
+    plan_hash: "abc123def456",
+    overall_verdict: "pass",
+    orchestration: createSampleOrchestratorResult(),
+    agents: {},
+    timestamp: "2026-02-08T10:30:00.000Z",
+    ...overrides,
+  };
+}
+
+export function createSampleAgentConfig(
+  overrides?: Partial<AgentConfig>,
+): AgentConfig {
+  return {
+    name: "test-agent",
+    model: "sonnet",
+    focus: "code quality",
+    enabled: true,
+    categories: ["code"],
+    description: "A test agent for unit testing.",
+    system_prompt: "You are a test agent.",
+    ...overrides,
+  };
+}
+
+export function createSamplePlanReviewConfig(
+  overrides?: Partial<PlanReviewConfig>,
+): PlanReviewConfig {
+  return {
+    ...overrides,
+  };
+}

package/dist/templates/cc-native/_cc-native/lib-ts/__tests__/hooks/add-plan-context.hook.test.ts

@@ -0,0 +1,97 @@
+import { expect } from "chai";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {
+  createTempDir, cleanupTempDir, createSampleState, createSampleIndex,
+  writeStateJson, writeIndexJson, createSampleHookInput, runHookSubprocess,
+} from "../../../../_core/lib-ts/__tests__/helpers.js";
+
+const HOOK_PATH = path.resolve(".aiwcli/_cc-native/hooks/add_plan_context.ts");
+
+describe("add_plan_context hook", () => {
+  let tmpDir: string;
+  const sessionId = "sess-plan-ctx";
+  const contextId = "ctx-plan-ctx";
+
+  beforeEach(() => {
+    tmpDir = createTempDir("hook-add-plan-ctx-");
+    writeStateJson(tmpDir, contextId, createSampleState({
+      id: contextId,
+      session_ids: [sessionId],
+    }));
+    writeIndexJson(tmpDir, createSampleIndex(
+      { [contextId]: { summary: "Test", mode: "active", last_active: "2026-02-08T10:00:00" } },
+      { [sessionId]: contextId },
+    ));
+  });
+
+  afterEach(() => cleanupTempDir(tmpDir));
+
+  it("skips for internal subprocess calls", async () => {
+    const input = createSampleHookInput({
+      hook_event_name: "PostToolUse",
+      tool_name: "AskUserQuestion",
+      session_id: sessionId,
+      cwd: tmpDir,
+    });
+    const result = await runHookSubprocess(HOOK_PATH, input, {
+      CLAUDE_PROJECT_DIR: tmpDir,
+      _CC_INTERNAL: "1",
+    });
+    expect(result.exitCode).to.equal(0);
+  });
+
+  it("marks questions asked on AskUserQuestion event", async () => {
+    const input = createSampleHookInput({
+      hook_event_name: "PostToolUse",
+      tool_name: "AskUserQuestion",
+      session_id: sessionId,
+      cwd: tmpDir,
+    });
+    const result = await runHookSubprocess(HOOK_PATH, input, {
+      CLAUDE_PROJECT_DIR: tmpDir,
+    });
+    expect(result.exitCode).to.equal(0);
+
+    // Verify cc_native.questions_asked was set
+    const state = JSON.parse(fs.readFileSync(
+      path.join(tmpDir, "_output", "contexts", contextId, "state.json"), "utf-8",
+    ));
+    expect(state.cc_native?.questions_asked?.asked).to.equal(true);
+  });
+
+  it("emits context for Plan Task when questions not asked", async () => {
+    const input = createSampleHookInput({
+      hook_event_name: "PreToolUse",
+      tool_name: "Task",
+      tool_input: { subagent_type: "Plan", prompt: "Make a plan" },
+      session_id: sessionId,
+      cwd: tmpDir,
+      permission_mode: "plan",
+    });
+    const result = await runHookSubprocess(HOOK_PATH, input, {
+      CLAUDE_PROJECT_DIR: tmpDir,
+    });
+    expect(result.exitCode).to.equal(0);
+    // Should emit advisory context
+    if (result.json?.hookSpecificOutput?.additionalContext) {
+      expect(result.json.hookSpecificOutput.additionalContext).to.include("AskUserQuestion");
+    }
+  });
+
+  it("skips for non-Plan Task tool", async () => {
+    const input = createSampleHookInput({
+      hook_event_name: "PreToolUse",
+      tool_name: "Task",
+      tool_input: { subagent_type: "Explore", prompt: "Search code" },
+      session_id: sessionId,
+      cwd: tmpDir,
+      permission_mode: "plan",
+    });
+    const result = await runHookSubprocess(HOOK_PATH, input, {
+      CLAUDE_PROJECT_DIR: tmpDir,
+    });
+    expect(result.exitCode).to.equal(0);
+    // Should not emit any context for non-Plan tasks
+  });
+});

package/dist/templates/cc-native/_cc-native/lib-ts/__tests__/hooks/plan-questions.hook.test.ts

@@ -0,0 +1,81 @@
+import { expect } from "chai";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {
+  createTempDir, cleanupTempDir, createSampleState, createSampleIndex,
+  writeStateJson, writeIndexJson, createSampleHookInput, runHookSubprocess,
+} from "../../../../_core/lib-ts/__tests__/helpers.js";
+
+const HOOK_PATH = path.resolve(".aiwcli/_cc-native/hooks/plan_questions_early.ts");
+
+describe("plan_questions_early hook", () => {
+  let tmpDir: string;
+  const sessionId = "sess-plan-q";
+  const contextId = "ctx-plan-q";
+
+  beforeEach(() => {
+    tmpDir = createTempDir("hook-plan-questions-");
+    writeStateJson(tmpDir, contextId, createSampleState({
+      id: contextId,
+      session_ids: [sessionId],
+    }));
+    writeIndexJson(tmpDir, createSampleIndex(
+      { [contextId]: { summary: "Test", mode: "active", last_active: "2026-02-08T10:00:00" } },
+      { [sessionId]: contextId },
+    ));
+  });
+
+  afterEach(() => cleanupTempDir(tmpDir));
+
+  it("injects Phase A prompt in plan mode", async () => {
+    const input = createSampleHookInput({
+      hook_event_name: "UserPromptSubmit",
+      session_id: sessionId,
+      cwd: tmpDir,
+      permission_mode: "plan",
+    });
+    const result = await runHookSubprocess(HOOK_PATH, input, {
+      CLAUDE_PROJECT_DIR: tmpDir,
+    });
+    expect(result.exitCode).to.equal(0);
+    // Should emit Phase A context
+    if (result.json?.hookSpecificOutput?.additionalContext) {
+      expect(result.json.hookSpecificOutput.additionalContext).to.include("Clarify Before Exploring");
+    }
+  });
+
+  it("skips when not in plan mode", async () => {
+    const input = createSampleHookInput({
+      hook_event_name: "UserPromptSubmit",
+      session_id: sessionId,
+      cwd: tmpDir,
+      permission_mode: "default",
+    });
+    const result = await runHookSubprocess(HOOK_PATH, input, {
+      CLAUDE_PROJECT_DIR: tmpDir,
+    });
+    expect(result.exitCode).to.equal(0);
+    // Should not emit anything
+    expect(result.stdout.trim()).to.equal("");
+  });
+
+  it("skips when questions already asked", async () => {
+    // Set questions_asked in state
+    const statePath = path.join(tmpDir, "_output", "contexts", contextId, "state.json");
+    const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+    state.cc_native = { questions_asked: { asked: true, asked_at: "2026-02-08T10:00:00" } };
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+
+    const input = createSampleHookInput({
+      hook_event_name: "UserPromptSubmit",
+      session_id: sessionId,
+      cwd: tmpDir,
+      permission_mode: "plan",
+    });
+    const result = await runHookSubprocess(HOOK_PATH, input, {
+      CLAUDE_PROJECT_DIR: tmpDir,
+    });
+    expect(result.exitCode).to.equal(0);
+    expect(result.stdout.trim()).to.equal("");
+  });
+});

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

@@ -0,0 +1,71 @@
+import { expect } from "chai";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {
+  createTempDir, cleanupTempDir, createSampleState, createSampleIndex,
+  writeStateJson, writeIndexJson, createSampleHookInput, runHookSubprocess,
+} from "../../../../_core/lib-ts/__tests__/helpers.js";
+
+const HOOK_PATH = path.resolve(".aiwcli/_cc-native/hooks/cc-native-plan-review.ts");
+
+describe("cc-native-plan-review hook (wiring)", () => {
+  let tmpDir: string;
+  const sessionId = "sess-plan-review";
+  const contextId = "ctx-plan-review";
+
+  beforeEach(() => {
+    tmpDir = createTempDir("hook-plan-review-");
+    writeStateJson(tmpDir, contextId, createSampleState({
+      id: contextId,
+      session_ids: [sessionId],
+    }));
+    writeIndexJson(tmpDir, createSampleIndex(
+      { [contextId]: { summary: "Test", mode: "active", last_active: "2026-02-08T10:00:00" } },
+      { [sessionId]: contextId },
+    ));
+  });
+
+  afterEach(() => cleanupTempDir(tmpDir));
+
+  it("skips for internal subprocess calls", async () => {
+    const input = createSampleHookInput({
+      hook_event_name: "PreToolUse",
+      tool_name: "ExitPlanMode",
+      session_id: sessionId,
+      cwd: tmpDir,
+    });
+    const result = await runHookSubprocess(HOOK_PATH, input, {
+      CLAUDE_PROJECT_DIR: tmpDir,
+      _CC_INTERNAL: "1",
+    });
+    expect(result.exitCode).to.equal(0);
+  });
+
+  it("exits cleanly when no plan file exists", async () => {
+    const input = createSampleHookInput({
+      hook_event_name: "PreToolUse",
+      tool_name: "ExitPlanMode",
+      session_id: sessionId,
+      cwd: tmpDir,
+      permission_mode: "plan",
+    });
+    const result = await runHookSubprocess(HOOK_PATH, input, {
+      CLAUDE_PROJECT_DIR: tmpDir,
+    });
+    // Should exit 0 - no plan found, skips gracefully
+    expect(result.exitCode).to.equal(0);
+  });
+
+  it("exits cleanly with no session_id", async () => {
+    const input = createSampleHookInput({
+      hook_event_name: "PreToolUse",
+      tool_name: "ExitPlanMode",
+      session_id: undefined,
+      cwd: tmpDir,
+    });
+    const result = await runHookSubprocess(HOOK_PATH, input, {
+      CLAUDE_PROJECT_DIR: tmpDir,
+    });
+    expect(result.exitCode).to.equal(0);
+  });
+});

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

@@ -0,0 +1,99 @@
+import { expect } from "chai";
+import { parseJsonMaybe, coerceToReview } from "../json-parser.js";
+
+describe("json-parser", () => {
+  describe("parseJsonMaybe", () => {
+    it("parses valid JSON object", () => {
+      const result = parseJsonMaybe('{"verdict": "pass"}');
+      expect(result).to.deep.equal({ verdict: "pass" });
+    });
+
+    it("returns null for empty string", () => {
+      expect(parseJsonMaybe("")).to.be.null;
+    });
+
+    it("returns null for whitespace only", () => {
+      expect(parseJsonMaybe("   ")).to.be.null;
+    });
+
+    it("extracts JSON from surrounding text (heuristic)", () => {
+      const result = parseJsonMaybe('Some text {"key": "value"} more text');
+      expect(result).to.deep.equal({ key: "value" });
+    });
+
+    it("returns null for arrays", () => {
+      expect(parseJsonMaybe("[1, 2, 3]")).to.be.null;
+    });
+
+    it("returns null for plain text without JSON", () => {
+      expect(parseJsonMaybe("just some text")).to.be.null;
+    });
+
+    it("logs warning for missing required fields but still returns parsed object", () => {
+      const result = parseJsonMaybe('{"other": "field"}', ["verdict"]);
+      expect(result).to.not.be.null;
+      expect(result!.other).to.equal("field");
+    });
+
+    it("handles malformed JSON with heuristic", () => {
+      const result = parseJsonMaybe('prefix {"a": 1} suffix');
+      expect(result).to.deep.equal({ a: 1 });
+    });
+
+    it("returns null for malformed JSON that cannot be extracted", () => {
+      expect(parseJsonMaybe("{invalid json}")).to.be.null;
+    });
+  });
+
+  describe("coerceToReview", () => {
+    it("returns error tuple for null input", () => {
+      const [ok, verdict, data] = coerceToReview(null);
+      expect(ok).to.be.false;
+      expect(verdict).to.equal("error");
+      expect(data.verdict).to.equal("fail");
+      expect(data.issues).to.have.length.greaterThan(0);
+    });
+
+    it("normalizes valid review data", () => {
+      const [ok, verdict, data] = coerceToReview({
+        verdict: "pass",
+        summary: "All good",
+        issues: [],
+      });
+      expect(ok).to.be.true;
+      expect(verdict).to.equal("pass");
+      expect(data.summary).to.equal("All good");
+      expect(data.summary_source).to.equal("reviewer");
+    });
+
+    it("defaults missing verdict to warn", () => {
+      const [ok, verdict, data] = coerceToReview({ summary: "test" });
+      expect(ok).to.be.true;
+      expect(verdict).to.equal("warn");
+    });
+
+    it("defaults invalid verdict to warn", () => {
+      const [, verdict] = coerceToReview({ verdict: "banana" });
+      expect(verdict).to.equal("warn");
+    });
+
+    it("defaults empty summary", () => {
+      const [, , data] = coerceToReview({ verdict: "pass" });
+      expect(data.summary).to.equal("No summary provided.");
+      expect(data.summary_source).to.equal("default");
+    });
+
+    it("handles missing issues/questions/missing_sections gracefully", () => {
+      const [ok, , data] = coerceToReview({ verdict: "pass", summary: "ok" });
+      expect(ok).to.be.true;
+      expect(data.issues).to.deep.equal([]);
+      expect(data.questions).to.deep.equal([]);
+      expect(data.missing_sections).to.deep.equal([]);
+    });
+
+    it("uses custom default fix message", () => {
+      const [, , data] = coerceToReview(null, "Custom fix");
+      expect(data.issues[0]?.suggested_fix).to.equal("Custom fix");
+    });
+  });
+});