@nathapp/nax 0.24.0 → 0.26.0

package/test/unit/execution/sequential-executor.test.ts

@@ -0,0 +1,235 @@
+/**
+ * Unit tests for cost trigger wiring in sequential-executor.ts (TC-001)
+ *
+ * Covers: checkCostExceeded abort/skip/continue, checkCostWarning at 80%/100%
+ * threshold, and isTriggerEnabled guard (no interaction plugin = today behavior).
+ */
+
+import { afterEach, describe, expect, mock, test } from "bun:test";
+import type { NaxConfig } from "../../../src/config";
+import { InteractionChain } from "../../../src/interaction/chain";
+import type { InteractionPlugin, InteractionResponse } from "../../../src/interaction/types";
+import { checkCostExceeded, checkCostWarning, checkPreMerge, isTriggerEnabled } from "../../../src/interaction/triggers";
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+
+function makeChain(action: InteractionResponse["action"]): InteractionChain {
+  const chain = new InteractionChain({ defaultTimeout: 5000, defaultFallback: "escalate" });
+  const plugin: InteractionPlugin = {
+    name: "test",
+    send: mock(async () => {}),
+    receive: mock(async (id: string): Promise<InteractionResponse> => ({
+      requestId: id,
+      action,
+      respondedBy: "user",
+      respondedAt: Date.now(),
+    })),
+  };
+  chain.register(plugin);
+  return chain;
+}
+
+function makeConfig(triggers: Record<string, unknown>): NaxConfig {
+  return {
+    interaction: {
+      plugin: "cli",
+      defaults: { timeout: 30000, fallback: "escalate" as const },
+      triggers,
+    },
+  } as unknown as NaxConfig;
+}
+
+afterEach(() => {
+  mock.restore();
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// isTriggerEnabled — no interaction plugin = today behavior
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("isTriggerEnabled — no interaction plugin configured", () => {
+  test("returns false when cost-exceeded is not in triggers", () => {
+    const config = makeConfig({});
+    expect(isTriggerEnabled("cost-exceeded", config)).toBe(false);
+  });
+
+  test("returns false when cost-warning is not in triggers", () => {
+    const config = makeConfig({});
+    expect(isTriggerEnabled("cost-warning", config)).toBe(false);
+  });
+
+  test("returns false when trigger explicitly disabled", () => {
+    const config = makeConfig({ "cost-exceeded": { enabled: false } });
+    expect(isTriggerEnabled("cost-exceeded", config)).toBe(false);
+  });
+
+  test("returns true when trigger is boolean true", () => {
+    const config = makeConfig({ "cost-warning": true });
+    expect(isTriggerEnabled("cost-warning", config)).toBe(true);
+  });
+
+  test("returns true when trigger is enabled:true object", () => {
+    const config = makeConfig({ "cost-exceeded": { enabled: true } });
+    expect(isTriggerEnabled("cost-exceeded", config)).toBe(true);
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// checkCostExceeded — 100% threshold responses
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("checkCostExceeded — abort response exits with cost-limit", () => {
+  const context = { featureName: "feature-x", cost: 1.0, limit: 1.0 };
+
+  test("returns false when trigger responds abort", async () => {
+    const config = makeConfig({ "cost-exceeded": { enabled: true } });
+    const chain = makeChain("abort");
+    const result = await checkCostExceeded(context, config, chain);
+    expect(result).toBe(false);
+  });
+
+  test("returns true (proceed past limit) when trigger responds skip", async () => {
+    const config = makeConfig({ "cost-exceeded": { enabled: true } });
+    const chain = makeChain("skip");
+    const result = await checkCostExceeded(context, config, chain);
+    expect(result).toBe(true);
+  });
+
+  test("returns true (proceed past limit) when trigger responds approve/continue", async () => {
+    const config = makeConfig({ "cost-exceeded": { enabled: true } });
+    const chain = makeChain("approve");
+    const result = await checkCostExceeded(context, config, chain);
+    expect(result).toBe(true);
+  });
+
+  test("returns true without prompting when trigger is disabled (today behavior preserved)", async () => {
+    const config = makeConfig({});
+    const chain = makeChain("abort");
+    const result = await checkCostExceeded(context, config, chain);
+    // Trigger disabled: checkCostExceeded returns true (caller decides to exit)
+    expect(result).toBe(true);
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// checkCostWarning — 80% threshold
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("checkCostWarning — 80% threshold", () => {
+  const context = { featureName: "feature-x", cost: 0.8, limit: 1.0 };
+
+  test("returns 'escalate' when trigger responds approve", async () => {
+    const config = makeConfig({ "cost-warning": { enabled: true } });
+    const chain = makeChain("approve");
+    const result = await checkCostWarning(context, config, chain);
+    expect(result).toBe("escalate");
+  });
+
+  test("returns 'continue' when trigger responds skip", async () => {
+    const config = makeConfig({ "cost-warning": { enabled: true } });
+    const chain = makeChain("skip");
+    const result = await checkCostWarning(context, config, chain);
+    expect(result).toBe("continue");
+  });
+
+  test("returns 'continue' when trigger responds abort", async () => {
+    const config = makeConfig({ "cost-warning": { enabled: true } });
+    const chain = makeChain("abort");
+    const result = await checkCostWarning(context, config, chain);
+    expect(result).toBe("continue");
+  });
+
+  test("returns 'continue' without prompting when trigger is disabled", async () => {
+    const config = makeConfig({});
+    const chain = makeChain("approve");
+    const result = await checkCostWarning(context, config, chain);
+    expect(result).toBe("continue");
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Threshold guard logic (mirrors executor warningSent guard)
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("cost-warning threshold guard logic", () => {
+  function shouldFireWarning(
+    totalCost: number,
+    costLimit: number,
+    triggerCfg: boolean | { enabled: boolean; threshold?: number } | undefined,
+    warningSent: boolean,
+  ): boolean {
+    if (warningSent) return false;
+    const threshold = typeof triggerCfg === "object" ? (triggerCfg.threshold ?? 0.8) : 0.8;
+    return totalCost >= costLimit * threshold;
+  }
+
+  test("does not fire when cost is below 80% of limit", () => {
+    expect(shouldFireWarning(7.9, 10, { enabled: true }, false)).toBe(false);
+  });
+
+  test("fires when cost is exactly at 80% of limit", () => {
+    expect(shouldFireWarning(8.0, 10, { enabled: true }, false)).toBe(true);
+  });
+
+  test("fires when cost is between 80% and 100% of limit", () => {
+    expect(shouldFireWarning(9.5, 10, { enabled: true }, false)).toBe(true);
+  });
+
+  test("fires when cost is at 100% of limit", () => {
+    expect(shouldFireWarning(10.0, 10, { enabled: true }, false)).toBe(true);
+  });
+
+  test("does not fire a second time if warningSent is true", () => {
+    expect(shouldFireWarning(9.0, 10, { enabled: true }, true)).toBe(false);
+  });
+
+  test("uses custom threshold when provided in trigger config", () => {
+    // threshold: 0.9 means fires at 90% not 80%
+    expect(shouldFireWarning(8.5, 10, { enabled: true, threshold: 0.9 }, false)).toBe(false);
+    expect(shouldFireWarning(9.0, 10, { enabled: true, threshold: 0.9 }, false)).toBe(true);
+  });
+
+  test("defaults to 0.8 when trigger config is a boolean", () => {
+    expect(shouldFireWarning(7.9, 10, true, false)).toBe(false);
+    expect(shouldFireWarning(8.0, 10, true, false)).toBe(true);
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// checkPreMerge — pre-merge trigger before run:completed
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe("checkPreMerge — approve/abort responses", () => {
+  const context = { featureName: "feature-x", totalStories: 3, cost: 0.5 };
+
+  test("returns false when trigger responds abort", async () => {
+    const config = makeConfig({ "pre-merge": { enabled: true } });
+    const chain = makeChain("abort");
+    const result = await checkPreMerge(context, config, chain);
+    expect(result).toBe(false);
+  });
+
+  test("returns true when trigger responds approve", async () => {
+    const config = makeConfig({ "pre-merge": { enabled: true } });
+    const chain = makeChain("approve");
+    const result = await checkPreMerge(context, config, chain);
+    expect(result).toBe(true);
+  });
+
+  test("returns false when trigger responds skip (non-approve = abort run)", async () => {
+    const config = makeConfig({ "pre-merge": { enabled: true } });
+    const chain = makeChain("skip");
+    const result = await checkPreMerge(context, config, chain);
+    expect(result).toBe(false);
+  });
+
+  test("returns true without prompting when trigger is disabled", async () => {
+    const config = makeConfig({});
+    const chain = makeChain("abort");
+    const result = await checkPreMerge(context, config, chain);
+    // Trigger disabled: checkPreMerge returns true (proceed normally)
+    expect(result).toBe(true);
+  });
+});

package/test/unit/interaction/auto-plugin.test.ts

@@ -0,0 +1,162 @@
+/**
+ * AutoInteractionPlugin unit tests (TC-006)
+ *
+ * Tests LLM decision path via _deps.callLlm mock.
+ * No real claude CLI is invoked.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { _deps, AutoInteractionPlugin } from "../../../src/interaction/plugins/auto";
+import type { InteractionRequest } from "../../../src/interaction/types";
+
+// Save original so we can restore in afterEach
+const originalCallLlm = _deps.callLlm;
+
+function makeRequest(id: string, overrides: Partial<InteractionRequest> = {}): InteractionRequest {
+  return {
+    id,
+    type: "confirm",
+    featureName: "test-feature",
+    stage: "review",
+    summary: "Should we proceed?",
+    fallback: "continue",
+    createdAt: Date.now(),
+    ...overrides,
+  };
+}
+
+describe("AutoInteractionPlugin._deps.callLlm", () => {
+  let plugin: AutoInteractionPlugin;
+
+  beforeEach(async () => {
+    plugin = new AutoInteractionPlugin();
+    await plugin.init({ confidenceThreshold: 0.7 });
+  });
+
+  afterEach(() => {
+    mock.restore();
+    _deps.callLlm = originalCallLlm;
+  });
+
+  test("LLM returns approve → response.action is approve", async () => {
+    _deps.callLlm = mock(async () => ({
+      action: "approve" as const,
+      confidence: 0.9,
+      reasoning: "safe to proceed",
+    }));
+
+    const response = await plugin.decide(makeRequest("req-approve"));
+
+    expect(response).not.toBeUndefined();
+    expect(response?.action).toBe("approve");
+    expect(response?.respondedBy).toBe("auto-ai");
+    expect(response?.requestId).toBe("req-approve");
+  });
+
+  test("LLM returns reject → response.action is reject", async () => {
+    _deps.callLlm = mock(async () => ({
+      action: "reject" as const,
+      confidence: 0.85,
+      reasoning: "potential issue",
+    }));
+
+    const response = await plugin.decide(makeRequest("req-reject"));
+
+    expect(response).not.toBeUndefined();
+    expect(response?.action).toBe("reject");
+  });
+
+  test("confidence < threshold → returns undefined (escalates to human)", async () => {
+    _deps.callLlm = mock(async () => ({
+      action: "approve" as const,
+      confidence: 0.5, // below default threshold of 0.7
+      reasoning: "not confident",
+    }));
+
+    const response = await plugin.decide(makeRequest("req-low-conf"));
+
+    expect(response).toBeUndefined();
+  });
+
+  test("custom threshold: confidence exactly at threshold → response returned", async () => {
+    const highThresholdPlugin = new AutoInteractionPlugin();
+    await highThresholdPlugin.init({ confidenceThreshold: 0.8 });
+
+    _deps.callLlm = mock(async () => ({
+      action: "approve" as const,
+      confidence: 0.8, // exactly at threshold
+      reasoning: "borderline",
+    }));
+
+    const response = await highThresholdPlugin.decide(makeRequest("req-threshold"));
+
+    // Confidence (0.8) is NOT less than threshold (0.8), so response is returned
+    expect(response).not.toBeUndefined();
+    expect(response?.action).toBe("approve");
+  });
+
+  test("custom threshold: confidence below threshold → returns undefined", async () => {
+    const highThresholdPlugin = new AutoInteractionPlugin();
+    await highThresholdPlugin.init({ confidenceThreshold: 0.9 });
+
+    _deps.callLlm = mock(async () => ({
+      action: "approve" as const,
+      confidence: 0.8, // below 0.9 threshold
+      reasoning: "not confident enough",
+    }));
+
+    const response = await highThresholdPlugin.decide(makeRequest("req-below-threshold"));
+
+    expect(response).toBeUndefined();
+  });
+
+  test("security-review trigger → always returns undefined (hardcoded block)", async () => {
+    // _deps.callLlm is NOT set — if it were called, it would throw (null)
+    // This verifies the security-review check runs before any LLM call
+    _deps.callLlm = mock(async () => {
+      throw new Error("callLlm should not be invoked for security-review");
+    });
+
+    const request = makeRequest("req-sec", {
+      metadata: { trigger: "security-review", safety: "red" },
+    });
+
+    const response = await plugin.decide(request);
+
+    expect(response).toBeUndefined();
+    // Verify LLM was never called
+    expect((_deps.callLlm as ReturnType<typeof mock>).mock.calls).toHaveLength(0);
+  });
+
+  test("LLM throws → returns undefined (error escalates to human)", async () => {
+    _deps.callLlm = mock(async () => {
+      throw new Error("LLM unavailable");
+    });
+
+    const response = await plugin.decide(makeRequest("req-error"));
+
+    expect(response).toBeUndefined();
+  });
+
+  test("LLM returns choose with value → value is propagated", async () => {
+    _deps.callLlm = mock(async () => ({
+      action: "choose" as const,
+      value: "option-b",
+      confidence: 0.95,
+      reasoning: "best option",
+    }));
+
+    const response = await plugin.decide(
+      makeRequest("req-choose", {
+        type: "choose",
+        options: [
+          { key: "a", label: "Option A" },
+          { key: "b", label: "Option B" },
+        ],
+      }),
+    );
+
+    expect(response?.action).toBe("choose");
+    expect(response?.value).toBe("option-b");
+  });
+});