muonroi-cli 1.8.1 → 1.8.4

package/dist/src/ee/extract-session.test.js

@@ -1,192 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { startStubEEServer } from "../__test-stubs__/ee-server.js";
-import { createEEClient } from "./client.js";
-import { buildExtractTranscript, extractSession } from "./extract-session.js";
-import { setDefaultEEClient } from "./intercept.js";
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-function makeUserMsg(text) {
-    return { role: "user", content: [{ type: "text", text }] };
-}
-function makeAssistantMsg(text) {
-    return { role: "assistant", content: [{ type: "text", text }] };
-}
-function makeToolResultMsg(result) {
-    return {
-        role: "tool",
-        content: [{ type: "tool-result", toolCallId: "x", output: result }],
-    };
-}
-function fiveUserMessages() {
-    return [
-        makeUserMsg("msg 1"),
-        makeAssistantMsg("reply 1"),
-        makeUserMsg("msg 2"),
-        makeAssistantMsg("reply 2"),
-        makeUserMsg("msg 3"),
-        makeAssistantMsg("reply 3"),
-        makeUserMsg("msg 4"),
-        makeAssistantMsg("reply 4"),
-        makeUserMsg("msg 5"),
-        makeAssistantMsg("reply 5"),
-    ];
-}
-// ─── Mocked client ────────────────────────────────────────────────────────────
-describe("extractSession — unit (mocked client)", () => {
-    const mockExtract = vi.fn().mockResolvedValue({ ok: true, mistakes: 0 });
-    const mockClient = {
-        extract: mockExtract,
-        health: vi.fn(),
-        intercept: vi.fn(),
-        posttool: vi.fn(),
-        routeModel: vi.fn(),
-        coldRoute: vi.fn(),
-        feedback: vi.fn(),
-        touch: vi.fn(),
-        routeFeedback: vi.fn(),
-        promptStale: vi.fn(),
-        stats: vi.fn(),
-        graph: vi.fn(),
-        timeline: vi.fn(),
-        gates: vi.fn(),
-        evolve: vi.fn(),
-        sharePrinciple: vi.fn(),
-        importPrinciple: vi.fn(),
-        routeTask: vi.fn(),
-        search: vi.fn(),
-        user: vi.fn(),
-    };
-    beforeEach(() => {
-        vi.clearAllMocks();
-        setDefaultEEClient(mockClient);
-    });
-    afterEach(() => {
-        // Reset to null so other tests use real client
-        setDefaultEEClient(null);
-    });
-    // Test 1: fewer than 5 user messages → skip
-    it("Test 1: returns immediately when < 5 user messages", async () => {
-        const messages = [makeUserMsg("a"), makeAssistantMsg("b"), makeUserMsg("c"), makeAssistantMsg("d")];
-        await extractSession(messages, "/proj", "cli-exit");
-        expect(mockExtract).not.toHaveBeenCalled();
-    });
-    // Test 2: exactly 4 user messages mixed with other roles → skip
-    it("Test 2: skips with exactly 4 user messages mixed with assistant/tool", async () => {
-        const messages = [
-            makeUserMsg("u1"),
-            makeAssistantMsg("a1"),
-            makeToolResultMsg("result1"),
-            makeUserMsg("u2"),
-            makeAssistantMsg("a2"),
-            makeUserMsg("u3"),
-            makeAssistantMsg("a3"),
-            makeUserMsg("u4"),
-        ];
-        await extractSession(messages, "/proj", "cli-exit");
-        expect(mockExtract).not.toHaveBeenCalled();
-    });
-    // Test 3: 5+ user messages → call extract
-    it("Test 3: calls client.extract() when >= 5 user messages", async () => {
-        await extractSession(fiveUserMessages(), "/proj", "cli-exit");
-        expect(mockExtract).toHaveBeenCalledOnce();
-    });
-    // Test 4: passes compacted transcript (string) not raw messages
-    it("Test 4: passes compacted transcript string to extract", async () => {
-        await extractSession(fiveUserMessages(), "/proj", "cli-exit");
-        const call = mockExtract.mock.calls[0];
-        expect(typeof call[0].transcript).toBe("string");
-        expect(call[0].transcript.length).toBeGreaterThan(0);
-        // Should be serialized text format (e.g. "[User]: ..."), NOT a JSON array string like '[{"role":...'
-        expect(call[0].transcript).not.toMatch(/^\[\{"role"/);
-    });
-    // Test 5: passes AbortSignal.timeout(2000) as second arg
-    it("Test 5: passes AbortSignal.timeout(2000) to client.extract()", async () => {
-        await extractSession(fiveUserMessages(), "/proj", "cli-exit");
-        const call = mockExtract.mock.calls[0];
-        const signal = call[1];
-        expect(signal).toBeInstanceOf(AbortSignal);
-        // The signal should not be aborted immediately (we have 2s budget)
-        expect(signal.aborted).toBe(false);
-    });
-    // Test 6: passes correct meta.source
-    it("Test 6a: passes meta.source='cli-exit' correctly", async () => {
-        await extractSession(fiveUserMessages(), "/proj", "cli-exit");
-        expect(mockExtract.mock.calls[0][0].meta?.source).toBe("cli-exit");
-    });
-    it("Test 6b: passes meta.source='cli-clear' correctly", async () => {
-        await extractSession(fiveUserMessages(), "/proj", "cli-clear");
-        expect(mockExtract.mock.calls[0][0].meta?.source).toBe("cli-clear");
-    });
-    // Test 7: swallows errors — never throws
-    it("Test 7: swallows errors from client.extract() and never throws", async () => {
-        mockExtract.mockRejectedValueOnce(new Error("EE server down"));
-        await expect(extractSession(fiveUserMessages(), "/proj", "cli-exit")).resolves.toBeUndefined();
-    });
-    // Test 10: resumed session (3 prior + 3 new = 6 total) triggers extraction (D-07)
-    it("Test 10: resumed session with 6 total user msgs triggers extraction", async () => {
-        // Simulate: 3 prior session user msgs + 3 new session user msgs = 6 total
-        const messages = [
-            makeUserMsg("prior 1"),
-            makeAssistantMsg("prior reply 1"),
-            makeUserMsg("prior 2"),
-            makeAssistantMsg("prior reply 2"),
-            makeUserMsg("prior 3"),
-            makeAssistantMsg("prior reply 3"),
-            makeUserMsg("new 1"),
-            makeAssistantMsg("new reply 1"),
-            makeUserMsg("new 2"),
-            makeAssistantMsg("new reply 2"),
-            makeUserMsg("new 3"),
-            makeAssistantMsg("new reply 3"),
-        ];
-        await extractSession(messages, "/proj", "cli-exit", "session-123");
-        expect(mockExtract).toHaveBeenCalledOnce();
-        expect(mockExtract.mock.calls[0][0].meta?.sessionId).toBe("session-123");
-    });
-});
-// ─── buildExtractTranscript unit tests ───────────────────────────────────────
-describe("buildExtractTranscript", () => {
-    // Test 8: truncates tool result bodies > 500 chars
-    it("Test 8: truncates tool result bodies longer than 500 chars", () => {
-        const longResult = "x".repeat(1000);
-        const messages = [
-            makeUserMsg("question"),
-            makeAssistantMsg("answer"),
-            makeToolResultMsg(longResult),
-        ];
-        const output = buildExtractTranscript(messages);
-        expect(output).toContain("[truncated]");
-        // The output should be shorter than the raw concatenation would be
-        expect(output.length).toBeLessThan(longResult.length + 200);
-    });
-    it("does not truncate tool results <= 500 chars", () => {
-        const shortResult = "y".repeat(499);
-        const messages = [
-            makeUserMsg("question"),
-            makeAssistantMsg("answer"),
-            makeToolResultMsg(shortResult),
-        ];
-        const output = buildExtractTranscript(messages);
-        expect(output).not.toContain("[truncated]");
-    });
-});
-// ─── Integration test (real stub server) ─────────────────────────────────────
-describe("extractSession — integration (real stub server)", () => {
-    it("Test 9: completes within 2s against stub with 3s latency (D-04)", async () => {
-        // Start stub with 3s artificial latency
-        const stub = await startStubEEServer({ latencyMs: 3000 });
-        const client = createEEClient({ baseUrl: `http://127.0.0.1:${stub.port}` });
-        setDefaultEEClient(client);
-        try {
-            const start = Date.now();
-            await extractSession(fiveUserMessages(), "/proj", "cli-exit");
-            const elapsed = Date.now() - start;
-            // AbortSignal.timeout(2000) fires, error is swallowed, function returns
-            expect(elapsed).toBeLessThan(2500);
-        }
-        finally {
-            setDefaultEEClient(null);
-            await stub.stop();
-        }
-    });
-});
-//# sourceMappingURL=extract-session.test.js.map

package/dist/src/ee/intercept.test.d.ts

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

package/dist/src/ee/intercept.test.js

@@ -1,171 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { startStubEEServer } from "../__test-stubs__/ee-server.js";
-import { createEEClient, resetEEClientState } from "./client.js";
-import { getLastSurfacedState, resetLastSurfacedState, setDefaultEEClient, updateLastSurfacedState, } from "./intercept.js";
-import { setRenderSink } from "./render.js";
-const baseReq = {
-    toolName: "bash",
-    toolInput: { command: "rm -rf /" },
-    cwd: "/tmp",
-    tenantId: "local",
-    scope: { kind: "global" },
-};
-const sampleMatch = {
-    principle_uuid: "p-uuid-001",
-    embedding_model_version: "nomic-embed-text-v1.5",
-    confidence: 0.85,
-    why: "Dangerous command detected",
-    message: "Avoid destructive commands",
-    scope_label: "global",
-    last_matched_at: "2026-04-30T00:00:00Z",
-};
-describe("updateLastSurfacedState / resetLastSurfacedState", () => {
-    afterEach(() => {
-        resetLastSurfacedState();
-    });
-    it("updateLastSurfacedState sets surfacedIds and timestamp", () => {
-        updateLastSurfacedState(["id-1", "id-2"]);
-        const state = getLastSurfacedState();
-        expect(state.surfacedIds).toEqual(["id-1", "id-2"]);
-        expect(typeof state.timestamp).toBe("string");
-        expect(state.timestamp).not.toBe("");
-    });
-    it("updateLastSurfacedState with empty array is a no-op", () => {
-        updateLastSurfacedState(["id-1"]);
-        updateLastSurfacedState([]);
-        const state = getLastSurfacedState();
-        // Should still have previous value
-        expect(state.surfacedIds).toEqual(["id-1"]);
-    });
-    it("resetLastSurfacedState clears surfacedIds to []", () => {
-        updateLastSurfacedState(["id-1"]);
-        resetLastSurfacedState();
-        const state = getLastSurfacedState();
-        expect(state.surfacedIds).toEqual([]);
-    });
-});
-describe("intercept integration", () => {
-    let stub;
-    let captured;
-    beforeEach(async () => {
-        captured = [];
-        setRenderSink((chunk) => captured.push(chunk));
-        resetEEClientState();
-    });
-    afterEach(async () => {
-        if (stub)
-            await stub.stop();
-    });
-    it("decision=block returns response unchanged (caller aborts)", async () => {
-        stub = await startStubEEServer({
-            intercept: () => ({ decision: "block", reason: "too dangerous" }),
-        });
-        const client = createEEClient({
-            baseUrl: `http://127.0.0.1:${stub.port}`,
-            timeoutMs: 2000,
-        });
-        setDefaultEEClient(client);
-        // Use the full intercept function (from intercept.ts)
-        const { intercept } = await import("./intercept.js");
-        const resp = await intercept(baseReq);
-        expect(resp.decision).toBe("block");
-        expect(resp.reason).toBe("too dangerous");
-        // No matches emitted on block
-        expect(captured).toHaveLength(0);
-    });
-    it("decision=allow with matches[] emits rendered lines via sink", async () => {
-        stub = await startStubEEServer({
-            intercept: () => ({
-                decision: "allow",
-                matches: [sampleMatch],
-            }),
-        });
-        const client = createEEClient({
-            baseUrl: `http://127.0.0.1:${stub.port}`,
-            timeoutMs: 2000,
-        });
-        setDefaultEEClient(client);
-        const { intercept } = await import("./intercept.js");
-        const resp = await intercept(baseReq);
-        expect(resp.decision).toBe("allow");
-        expect(resp.matches).toHaveLength(1);
-        // The render sink captures StreamChunk objects; check rendered content
-        const getContent = (c) => (typeof c === "string" ? c : (c?.content ?? JSON.stringify(c)));
-        expect(captured).toHaveLength(1);
-        expect(getContent(captured[0])).toContain("Avoid destructive commands");
-        expect(getContent(captured[0])).toContain("Dangerous command detected");
-        expect(getContent(captured[0])).toContain("global");
-    });
-    it("posttool carries tenantId + scope (awaitable Promise<void>)", async () => {
-        stub = await startStubEEServer({
-            posttool: () => { },
-        });
-        const client = createEEClient({
-            baseUrl: `http://127.0.0.1:${stub.port}`,
-            timeoutMs: 2000,
-        });
-        setDefaultEEClient(client);
-        const { posttool } = await import("./posttool.js");
-        // posttool is now async (Promise<void>) so it can be awaited by PostToolUse handler
-        const result = posttool({
-            toolName: "bash",
-            toolInput: { command: "ls" },
-            outcome: { success: true },
-            cwd: "/tmp",
-            tenantId: "local",
-            scope: { kind: "global" },
-        });
-        expect(result).toBeInstanceOf(Promise);
-        await result; // await to let HTTP settle
-        expect(stub.calls.posttool).toHaveLength(1);
-        expect(stub.calls.posttool[0].tenantId).toBe("local");
-        expect(stub.calls.posttool[0].scope).toEqual({ kind: "global" });
-    });
-});
-describe("401 refresh path", () => {
-    let stub;
-    beforeEach(() => {
-        resetEEClientState();
-    });
-    afterEach(async () => {
-        if (stub)
-            await stub.stop();
-    });
-    it("retries once with refreshed token on 401", async () => {
-        let _callCount = 0;
-        stub = await startStubEEServer({
-            intercept: () => {
-                _callCount++;
-                // First call should be the retry after 401
-                return { decision: "allow", matches: [sampleMatch] };
-            },
-        });
-        // We need a custom intercept flow that handles 401.
-        // The 401 is surfaced by the client as reason='auth-required'.
-        // For this test, we'll mock the fetch to return 401 first, then succeed.
-        let fetchCallCount = 0;
-        const mockFetch = (async (input, init) => {
-            fetchCallCount++;
-            if (fetchCallCount === 1) {
-                // First call: return 401
-                return new Response(JSON.stringify({ error: "unauthorized" }), {
-                    status: 401,
-                    headers: { "Content-Type": "application/json" },
-                });
-            }
-            // Subsequent calls: proxy to real stub
-            const url = typeof input === "string" ? input : input.url;
-            const stubUrl = url.replace(/http:\/\/[^/]+/, `http://127.0.0.1:${stub.port}`);
-            return fetch(stubUrl, init);
-        });
-        const client = createEEClient({
-            baseUrl: `http://127.0.0.1:${stub.port}`,
-            timeoutMs: 2000,
-            fetchImpl: mockFetch,
-        });
-        // Test that the client returns auth-required on 401
-        const resp = await client.intercept(baseReq);
-        expect(resp.reason).toBe("auth-required");
-    });
-});
-//# sourceMappingURL=intercept.test.js.map

package/dist/src/ee/judge.test.d.ts

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

package/dist/src/ee/judge.test.js

@@ -1,190 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { fireFeedback, judge } from "./judge.js";
-// Mock the intercept module to control getDefaultEEClient
-const mockFeedback = vi.fn();
-const mockTouch = vi.fn();
-vi.mock("./intercept.js", () => ({
-    getDefaultEEClient: () => ({
-        feedback: mockFeedback,
-        touch: mockTouch,
-    }),
-}));
-function makeMatch(overrides = {}) {
-    return {
-        principle_uuid: "P1",
-        embedding_model_version: "v1",
-        confidence: 0.9,
-        why: "test reason",
-        message: "test message",
-        scope_label: "global",
-        last_matched_at: new Date().toISOString(),
-        ...overrides,
-    };
-}
-function makeCtx(overrides = {}) {
-    return {
-        warningResponse: {
-            decision: "allow",
-            matches: [makeMatch()],
-        },
-        toolName: "Edit",
-        outcome: { success: true, durationMs: 50 },
-        cwdMatchedAtPretool: true,
-        diffPresent: false,
-        tenantId: "local",
-        ...overrides,
-    };
-}
-describe("judge() deterministic classifier", () => {
-    it("no warningResponse.matches returns IRRELEVANT", () => {
-        const ctx = makeCtx({ warningResponse: { decision: "allow" } });
-        expect(judge(ctx)).toBe("IRRELEVANT");
-    });
-    it("empty matches array returns IRRELEVANT", () => {
-        const ctx = makeCtx({
-            warningResponse: { decision: "allow", matches: [] },
-        });
-        expect(judge(ctx)).toBe("IRRELEVANT");
-    });
-    it("cwdMatchedAtPretool=false returns IRRELEVANT", () => {
-        const ctx = makeCtx({ cwdMatchedAtPretool: false });
-        expect(judge(ctx)).toBe("IRRELEVANT");
-    });
-    it("successful outcome with matches returns FOLLOWED", () => {
-        const ctx = makeCtx();
-        expect(judge(ctx)).toBe("FOLLOWED");
-    });
-    it("failed outcome with matches returns IGNORED", () => {
-        const ctx = makeCtx({
-            outcome: { success: false, durationMs: 10 },
-        });
-        expect(judge(ctx)).toBe("IGNORED");
-    });
-    it("expectedBehavior=should-not-edit AND diffPresent=true returns IGNORED even with success", () => {
-        const ctx = makeCtx({
-            warningResponse: {
-                decision: "allow",
-                matches: [makeMatch({ expectedBehavior: "should-not-edit" })],
-            },
-            diffPresent: true,
-        });
-        expect(judge(ctx)).toBe("IGNORED");
-    });
-    it("expectedBehavior=should-not-edit AND diffPresent=false returns FOLLOWED", () => {
-        const ctx = makeCtx({
-            warningResponse: {
-                decision: "allow",
-                matches: [makeMatch({ expectedBehavior: "should-not-edit" })],
-            },
-            diffPresent: false,
-        });
-        expect(judge(ctx)).toBe("FOLLOWED");
-    });
-    it("null warningResponse returns IRRELEVANT", () => {
-        const ctx = makeCtx({ warningResponse: null });
-        expect(judge(ctx)).toBe("IRRELEVANT");
-    });
-    it("all matches below noise threshold returns IRRELEVANT", () => {
-        const ctx = makeCtx({
-            warningResponse: {
-                decision: "allow",
-                matches: [makeMatch({ confidence: 0.1 }), makeMatch({ confidence: 0.2 })],
-            },
-        });
-        expect(judge(ctx)).toBe("IRRELEVANT");
-    });
-    it("mix of low and high confidence returns FOLLOWED", () => {
-        const ctx = makeCtx({
-            warningResponse: {
-                decision: "allow",
-                matches: [makeMatch({ confidence: 0.1 }), makeMatch({ confidence: 0.8 })],
-            },
-        });
-        expect(judge(ctx)).toBe("FOLLOWED");
-    });
-    it("match exactly at noise threshold returns FOLLOWED", () => {
-        const ctx = makeCtx({
-            warningResponse: {
-                decision: "allow",
-                matches: [makeMatch({ confidence: 0.3 })],
-            },
-        });
-        expect(judge(ctx)).toBe("FOLLOWED");
-    });
-    it("match just below noise threshold returns IRRELEVANT", () => {
-        const ctx = makeCtx({
-            warningResponse: {
-                decision: "allow",
-                matches: [makeMatch({ confidence: 0.29 })],
-            },
-        });
-        expect(judge(ctx)).toBe("IRRELEVANT");
-    });
-});
-describe("fireFeedback()", () => {
-    beforeEach(() => {
-        mockFeedback.mockClear();
-        mockTouch.mockClear();
-    });
-    it("FOLLOWED: calls feedback() once per match AND touch() once per match", () => {
-        const ctx = makeCtx({
-            warningResponse: {
-                decision: "allow",
-                matches: [makeMatch({ principle_uuid: "P1" })],
-            },
-        });
-        fireFeedback(ctx);
-        expect(mockFeedback).toHaveBeenCalledOnce();
-        expect(mockFeedback).toHaveBeenCalledWith(expect.objectContaining({
-            principle_uuid: "P1",
-            classification: "FOLLOWED",
-            tool_name: "Edit",
-        }));
-        expect(mockTouch).toHaveBeenCalledOnce();
-        expect(mockTouch).toHaveBeenCalledWith("P1", "local");
-    });
-    it("IGNORED: calls feedback() but NOT touch()", () => {
-        const ctx = makeCtx({
-            outcome: { success: false, durationMs: 10 },
-        });
-        fireFeedback(ctx);
-        expect(mockFeedback).toHaveBeenCalledOnce();
-        expect(mockFeedback).toHaveBeenCalledWith(expect.objectContaining({ classification: "IGNORED" }));
-        expect(mockTouch).not.toHaveBeenCalled();
-    });
-    it("IRRELEVANT (no matches): does not call feedback or touch", () => {
-        const ctx = makeCtx({ warningResponse: null });
-        fireFeedback(ctx);
-        expect(mockFeedback).not.toHaveBeenCalled();
-        expect(mockTouch).not.toHaveBeenCalled();
-    });
-    it("multiple matches: calls feedback and touch for each", () => {
-        const ctx = makeCtx({
-            warningResponse: {
-                decision: "allow",
-                matches: [makeMatch({ principle_uuid: "P1" }), makeMatch({ principle_uuid: "P2" })],
-            },
-        });
-        fireFeedback(ctx);
-        expect(mockFeedback).toHaveBeenCalledTimes(2);
-        expect(mockTouch).toHaveBeenCalledTimes(2);
-        expect(mockTouch).toHaveBeenCalledWith("P1", "local");
-        expect(mockTouch).toHaveBeenCalledWith("P2", "local");
-    });
-    it("noise matches (all below threshold): sends IRRELEVANT feedback, no touch", () => {
-        const ctx = makeCtx({
-            warningResponse: {
-                decision: "allow",
-                matches: [
-                    makeMatch({ principle_uuid: "P1", confidence: 0.1 }),
-                    makeMatch({ principle_uuid: "P2", confidence: 0.2 }),
-                ],
-            },
-        });
-        fireFeedback(ctx);
-        expect(mockFeedback).toHaveBeenCalledTimes(2);
-        expect(mockFeedback).toHaveBeenCalledWith(expect.objectContaining({ classification: "IRRELEVANT" }));
-        expect(mockTouch).not.toHaveBeenCalled();
-    });
-});
-//# sourceMappingURL=judge.test.js.map

package/dist/src/ee/mistake-detector.test.d.ts

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