muonroi-cli 1.8.1 → 1.8.3

package/dist/src/pil/__tests__/discovery.test.js

@@ -1,178 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-vi.mock("../../ee/bridge.js", () => ({
-    searchByText: vi.fn().mockResolvedValue([]),
-}));
-import { runDiscovery } from "../discovery.js";
-import { clearDiscoveryCache } from "../discovery-cache.js";
-afterEach(() => clearDiscoveryCache());
-const mockHandler = {
-    askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text: "Error disappears", kind: "choice" }),
-};
-describe("runDiscovery()", () => {
-    it("proceeds without interview when the model proposes no cards", async () => {
-        const handler = {
-            askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text: "x", kind: "choice" }),
-        };
-        const proposer = vi.fn().mockResolvedValue([]);
-        const result = await runDiscovery("fix TypeError in src/auth/login.ts:42", {
-            taskType: "debug",
-            confidence: 0.9,
-            complexity: "low",
-            domain: "typescript",
-            outputStyle: "balanced",
-            intentKind: "task",
-        }, process.cwd(), handler, null, proposer);
-        expect(proposer).toHaveBeenCalled();
-        expect(result.interviewed).toBe(false);
-        expect(result.accepted).toBe(true);
-        expect(handler.askQuestion).not.toHaveBeenCalled();
-    });
-    it("does NOT interview when no proposer is wired", async () => {
-        const handler = {
-            askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text: "x", kind: "choice" }),
-        };
-        const result = await runDiscovery("fix auth", {
-            taskType: "debug",
-            confidence: 0.6,
-            complexity: "low",
-            domain: "typescript",
-            outputStyle: null,
-            intentKind: "task",
-        }, process.cwd(), handler, null, null);
-        expect(result.interviewed).toBe(false);
-        expect(result.accepted).toBe(true);
-        expect(handler.askQuestion).not.toHaveBeenCalled();
-    });
-    it("interviews user when the model proposes cards", async () => {
-        const askQuestion = vi.fn().mockResolvedValue({ questionId: "q1", text: "Error disappears", kind: "choice" });
-        const handler = { askQuestion };
-        const modelCards = [
-            {
-                question: "What outcome do you expect?",
-                options: [
-                    { label: "Error disappears", kind: "choice" },
-                    { label: "Not sure", kind: "freetext" },
-                ],
-                defaultIndex: 0,
-            },
-        ];
-        const proposer = vi.fn().mockResolvedValue(modelCards);
-        const result = await runDiscovery("fix auth", {
-            taskType: "debug",
-            confidence: 0.6,
-            complexity: "low",
-            domain: "typescript",
-            outputStyle: null,
-            intentKind: "task",
-        }, process.cwd(), handler, null, proposer);
-        expect(result.interviewed).toBe(true);
-        expect(result.accepted).toBe(true);
-        expect(handler.askQuestion).toHaveBeenCalled();
-        expect(result.interviewTranscript).toHaveLength(1);
-        expect(result.interviewTranscript[0].question).toBe("What outcome do you expect?");
-        expect(result.interviewTranscript[0].answer).toBe("Error disappears");
-    });
-    it("records multiple cards in the interview transcript", async () => {
-        const askQuestion = vi
-            .fn()
-            .mockResolvedValueOnce({ questionId: "q1", text: "OAuth", kind: "choice" })
-            .mockResolvedValueOnce({ questionId: "q2", text: "src/auth/", kind: "choice" });
-        const handler = { askQuestion };
-        const modelCards = [
-            {
-                question: "Which auth method?",
-                options: [
-                    { label: "OAuth", kind: "choice" },
-                    { label: "API Keys", kind: "choice" },
-                ],
-                defaultIndex: 0,
-            },
-            {
-                question: "Which module?",
-                options: [
-                    { label: "src/auth/", kind: "choice" },
-                    { label: "src/user/", kind: "choice" },
-                ],
-                defaultIndex: 0,
-            },
-        ];
-        const proposer = vi.fn().mockResolvedValue(modelCards);
-        const result = await runDiscovery("add authentication", {
-            taskType: "generate",
-            confidence: 0.6,
-            complexity: "low",
-            domain: null,
-            outputStyle: null,
-            intentKind: "task",
-        }, process.cwd(), handler, null, proposer);
-        expect(result.interviewTranscript).toHaveLength(2);
-        expect(result.interviewTranscript[0].question).toBe("Which auth method?");
-        expect(result.interviewTranscript[0].answer).toBe("OAuth");
-        expect(result.interviewTranscript[1].question).toBe("Which module?");
-        expect(result.interviewTranscript[1].answer).toBe("src/auth/");
-    });
-    it("sets accepted=false when user picks a cancel option", async () => {
-        const askQuestion = vi
-            .fn()
-            .mockResolvedValueOnce({ questionId: "q1", text: "Cancel this request", kind: "choice" });
-        const handler = { askQuestion };
-        const modelCards = [
-            {
-                question: "What outcome?",
-                options: [
-                    { label: "Proceed", kind: "choice" },
-                    { label: "Cancel this request", kind: "choice", isCancel: true },
-                ],
-                defaultIndex: 0,
-            },
-        ];
-        const proposer = vi.fn().mockResolvedValue(modelCards);
-        const result = await runDiscovery("fix auth", {
-            taskType: "debug",
-            confidence: 0.6,
-            complexity: "low",
-            domain: "typescript",
-            outputStyle: null,
-            intentKind: "task",
-        }, process.cwd(), handler, null, proposer);
-        expect(result.accepted).toBe(false);
-    });
-    it("skips all discovery when the user explicitly says don't ask (EN + VI)", async () => {
-        const handler = {
-            askQuestion: vi.fn().mockResolvedValue({ questionId: "q1", text: "x", kind: "choice" }),
-        };
-        const l1 = {
-            taskType: "analyze",
-            confidence: 0.6,
-            complexity: "low",
-            domain: null,
-            outputStyle: null,
-            intentKind: "task",
-        };
-        const enResult = await runDiscovery("analyze the orchestrator, just answer, don't ask", l1, process.cwd(), handler);
-        expect(enResult.interviewed).toBe(false);
-        expect(enResult.accepted).toBe(true);
-        const viResult = await runDiscovery("phân tích orchestrator, đừng hỏi, trả lời thẳng", l1, process.cwd(), handler);
-        expect(viResult.interviewed).toBe(false);
-        expect(viResult.accepted).toBe(true);
-        expect(handler.askQuestion).not.toHaveBeenCalled();
-    });
-    it("skips interview but still passes when handler is null (headless)", async () => {
-        const result = await runDiscovery("fix auth", {
-            taskType: "debug",
-            confidence: 0.6,
-            complexity: "low",
-            domain: "typescript",
-            outputStyle: null,
-            intentKind: "task",
-        }, process.cwd(), null);
-        expect(result.interviewed).toBe(false);
-        expect(result.accepted).toBe(true);
-    });
-    it("skips discovery entirely for chitchat", async () => {
-        const result = await runDiscovery("hi", { taskType: null, confidence: 0.5, complexity: "low", domain: null, outputStyle: null, intentKind: "chitchat" }, process.cwd(), mockHandler);
-        expect(result.interviewed).toBe(false);
-        expect(result.accepted).toBe(true);
-    });
-});
-//# sourceMappingURL=discovery.test.js.map

package/dist/src/pil/__tests__/dual-run.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/pil/__tests__/dual-run.test.js

@@ -1,51 +0,0 @@
-// Dual-run validator: ensures legacy and unified paths produce equivalent
-// classifications on a representative fixture set. Divergence > 10% fails.
-import { beforeEach, describe, expect, it, vi } from "vitest";
-// Stub the EE bridge so both legacy and unified paths behave identically
-// in CI (no experience-engine server available). Without this, unified=1
-// triggers a real HTTP call that either times out (exceeding the 200ms pipeline
-// timeout) or returns null — producing different taskType results from legacy=0,
-// which skips the HTTP call entirely.
-vi.mock("../../ee/bridge.js", () => ({
-    classifyViaBrain: vi.fn().mockResolvedValue(null),
-    searchCollection: vi.fn().mockResolvedValue([]),
-    getEmbeddingRaw: vi.fn().mockResolvedValue(null),
-    routeTask: vi.fn().mockResolvedValue(null),
-    pilContext: vi.fn().mockResolvedValue(null),
-    getWhoAmIProfile: vi.fn(() => null),
-    outputStyleFromProfile: vi.fn(() => null),
-}));
-const FIXTURES = [
-    "tại sao test fail?",
-    "refactor this function",
-    "thiết kế hệ thống auth cho team 3 người",
-    "hi",
-    "fix the bug in login flow",
-    "explain this regex /^\\d+$/",
-    "write docs for the API endpoint",
-    "generate a TypeScript Zod schema for User",
-    "phân tích lỗi memory leak trong service",
-    "ok thanks",
-];
-describe("Dual-run: unified vs legacy", () => {
-    beforeEach(() => {
-        vi.resetModules();
-    });
-    it("classification matches in ≥90% of fixtures", async () => {
-        process.env.MUONROI_PIL_UNIFIED = "0";
-        const { runPipeline: runLegacy } = await import("../pipeline.js");
-        const legacyResults = await Promise.all(FIXTURES.map((p) => runLegacy(p)));
-        vi.resetModules();
-        process.env.MUONROI_PIL_UNIFIED = "1";
-        const { runPipeline: runUnified } = await import("../pipeline.js");
-        const unifiedResults = await Promise.all(FIXTURES.map((p) => runUnified(p)));
-        let matches = 0;
-        for (let i = 0; i < FIXTURES.length; i++) {
-            if (legacyResults[i].taskType === unifiedResults[i].taskType)
-                matches++;
-        }
-        const matchRate = matches / FIXTURES.length;
-        expect(matchRate).toBeGreaterThanOrEqual(0.9);
-    });
-});
-//# sourceMappingURL=dual-run.test.js.map

package/dist/src/pil/__tests__/layer1-intent-trace.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/pil/__tests__/layer1-intent-trace.test.js

@@ -1,138 +0,0 @@
-/**
- * Tests for the IntentDetectionTrace returned by Layer 1.
- * Verifies that each pass marks itself correctly in the trace so the
- * pil-report command can answer "which pass actually decided the outcome".
- */
-import { beforeEach, describe, expect, it, vi } from "vitest";
-const { mockClassify, mockClassifyViaBrain, mockPilContext, mockIsUnifiedPilEnabled, mockIsLlmFirstClassifyEnabled } = vi.hoisted(() => ({
-    mockClassify: vi.fn(),
-    mockClassifyViaBrain: vi.fn(),
-    mockPilContext: vi.fn(),
-    mockIsUnifiedPilEnabled: vi.fn(),
-    // OFF so these trace tests exercise the regex cascade passes.
-    mockIsLlmFirstClassifyEnabled: vi.fn(() => false),
-}));
-vi.mock("../../router/classifier/index.js", () => ({ classify: mockClassify }));
-vi.mock("../../ee/bridge.js", () => ({
-    classifyViaBrain: mockClassifyViaBrain,
-    pilContext: mockPilContext,
-}));
-vi.mock("../config.js", () => ({
-    isUnifiedPilEnabled: mockIsUnifiedPilEnabled,
-    isLlmFirstClassifyEnabled: mockIsLlmFirstClassifyEnabled,
-    // Pass-3 unified reads the client-side budget; whole-module mock replaces the
-    // real export, so it must be provided or the call site throws.
-    getUnifiedPilBudgetMs: vi.fn(() => 3500),
-}));
-import { layer1Intent } from "../layer1-intent.js";
-function makeCtx(raw) {
-    return {
-        raw,
-        enriched: raw,
-        taskType: null,
-        domain: null,
-        confidence: 0,
-        outputStyle: null,
-        tokenBudget: 500,
-        metrics: null,
-        layers: [],
-    };
-}
-beforeEach(() => {
-    vi.resetAllMocks();
-    mockIsUnifiedPilEnabled.mockReturnValue(false);
-    mockClassifyViaBrain.mockResolvedValue(null);
-    mockPilContext.mockResolvedValue(null);
-});
-describe("IntentDetectionTrace", () => {
-    it("Pass 1 hit: high-confidence classifier reason maps to taskType; no legacy TASK brain call", async () => {
-        // Phase 4 4P-1: switched from tree-sitter:typescript (now undefined) to
-        // regex:refactor — a real Pass 1 mapping that survives Phase 4.
-        mockClassify.mockReturnValue({ tier: "hot", reason: "regex:refactor", confidence: 0.95 });
-        const result = await layer1Intent(makeCtx("rename foo to bar across the module"));
-        const trace = result._intentTrace;
-        expect(trace.pass1Reason).toBe("regex:refactor");
-        expect(trace.pass1TaskType).toBe("refactor");
-        expect(trace.pass1Hit).toBe(true);
-        expect(trace.pass2Hit).toBe(false);
-        expect(trace.pass25ChitchatHit).toBe(false);
-        expect(trace.pass3UnifiedAttempted).toBe(false);
-        expect(trace.pass3LegacyTaskAttempted).toBe(false);
-        // Style brain may still fire (no explicit style cue in prompt) — that's
-        // the 800ms style call, separately tracked.
-        expect(trace.finalTaskType).toBe("refactor");
-    });
-    it("Pass 2 hit: keyword fallback picks up debug; no legacy TASK brain call", async () => {
-        mockClassify.mockReturnValue({ tier: "abstain", reason: "regex:no-match", confidence: 0.1 });
-        const result = await layer1Intent(makeCtx("there is a bug in the login flow"));
-        const trace = result._intentTrace;
-        expect(trace.pass1Hit).toBe(false);
-        expect(trace.pass2Hit).toBe(true);
-        expect(trace.pass2Pattern).toMatch(/bug/);
-        expect(trace.pass3LegacyTaskAttempted).toBe(false);
-        expect(trace.finalTaskType).toBe("debug");
-    });
-    it("Pass 2.5 chitchat hit: short greeting takes the hot-path", async () => {
-        mockClassify.mockReturnValue({ tier: "hot", reason: "regex:short-message", confidence: 0.3 });
-        const result = await layer1Intent(makeCtx("hi"));
-        const trace = result._intentTrace;
-        expect(trace.pass25ChitchatHit).toBe(true);
-        expect(trace.finalTaskType).toBe("general");
-        expect(trace.styleSource).toBe("chitchat-default");
-        expect(mockClassifyViaBrain).not.toHaveBeenCalled();
-    });
-    it("Pass 3 unified attempted + succeeded when flag is on and local signal weak", async () => {
-        mockIsUnifiedPilEnabled.mockReturnValue(true);
-        mockClassify.mockReturnValue({ tier: "abstain", reason: "regex:no-match", confidence: 0.1 });
-        mockPilContext.mockResolvedValueOnce({
-            taskType: "plan",
-            intentKind: "task",
-            outputStyle: "balanced",
-            confidence: 0.8,
-            t0_principles: [],
-            t1_rules: [],
-            t2_patterns: [],
-            retrieval_skipped_reason: null,
-        });
-        const result = await layer1Intent(makeCtx("vague architecture question"));
-        const trace = result._intentTrace;
-        expect(trace.pass3UnifiedAttempted).toBe(true);
-        expect(trace.pass3UnifiedSucceeded).toBe(true);
-        expect(trace.pass3LegacyTaskAttempted).toBe(false);
-        expect(trace.pass3LegacyStyleAttempted).toBe(false);
-        expect(trace.styleSource).toBe("brain-unified");
-        expect(trace.finalTaskType).toBe("plan");
-    });
-    it("Pass 3 unified attempted but failed: legacy NOT attempted (cost optimization)", async () => {
-        mockIsUnifiedPilEnabled.mockReturnValue(true);
-        mockClassify.mockReturnValue({ tier: "abstain", reason: "regex:no-match", confidence: 0.1 });
-        mockPilContext.mockResolvedValueOnce(null);
-        const result = await layer1Intent(makeCtx("vague question"));
-        const trace = result._intentTrace;
-        expect(trace.pass3UnifiedAttempted).toBe(true);
-        expect(trace.pass3UnifiedSucceeded).toBe(false);
-        expect(trace.pass3LegacyTaskAttempted).toBe(false);
-        expect(trace.pass3LegacyStyleAttempted).toBe(false);
-        expect(mockClassifyViaBrain).not.toHaveBeenCalled();
-    });
-    it("Pass1 coding reason → styleSource=classifier-default without brain call", async () => {
-        mockClassify.mockReturnValue({ tier: "hot", reason: "regex:edit", confidence: 0.85 });
-        const result = await layer1Intent(makeCtx("edit this handler"));
-        const trace = result._intentTrace;
-        expect(trace.pass1Hit).toBe(true);
-        expect(trace.pass3LegacyStyleAttempted).toBe(false);
-        expect(trace.styleSource).toBe("classifier-default");
-        expect(result.outputStyle).toBe("balanced");
-        expect(mockClassifyViaBrain).not.toHaveBeenCalled();
-    });
-    it("Explicit style cue takes the regex path (styleSource=explicit-regex) and skips brain", async () => {
-        mockClassify.mockReturnValue({ tier: "abstain", reason: "regex:no-match", confidence: 0.1 });
-        const result = await layer1Intent(makeCtx("plan the architecture, chi tiết nhé"));
-        const trace = result._intentTrace;
-        expect(trace.pass2Hit).toBe(true);
-        expect(trace.styleSource).toBe("explicit-regex");
-        expect(result.outputStyle).toBe("detailed");
-        expect(trace.pass3LegacyStyleAttempted).toBe(false);
-    });
-});
-//# sourceMappingURL=layer1-intent-trace.test.js.map

package/dist/src/pil/__tests__/layer1-intent.test.d.ts

@@ -1 +0,0 @@
-export {};