muonroi-cli 1.8.1 → 1.8.3

package/dist/src/chat/__tests__/intent-prompt.test.js

@@ -1,80 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildConvoPrompt, parseConvoReply, SYSTEM_PROMPT } from "../intent-prompt.js";
-describe("intent-prompt", () => {
-    it("SYSTEM_PROMPT contains intent semantics", () => {
-        expect(SYSTEM_PROMPT).toContain("accept");
-        expect(SYSTEM_PROMPT).toContain("reject");
-        expect(SYSTEM_PROMPT).toContain("abort");
-        expect(SYSTEM_PROMPT).toContain("discuss");
-    });
-    it("SYSTEM_PROMPT instructs language match (default Vietnamese)", () => {
-        expect(SYSTEM_PROMPT.toLowerCase()).toMatch(/vietnamese|language/);
-    });
-    it("SYSTEM_PROMPT forbids keyword matching", () => {
-        expect(SYSTEM_PROMPT.toLowerCase()).toMatch(/keyword|negation|conservative/);
-    });
-    it("buildConvoPrompt includes review summary, prior turns, new msg", () => {
-        const out = buildConvoPrompt({
-            reviewSummary: "Sprint done.",
-            productName: "Demo",
-            priorTurns: [
-                { role: "customer", content: "looks good?" },
-                { role: "bot", content: "yes" },
-            ],
-            newMessage: "I accept",
-        });
-        expect(out).toContain("Sprint done.");
-        expect(out).toContain("looks good?");
-        expect(out).toContain("yes");
-        expect(out).toContain("I accept");
-    });
-    it("buildConvoPrompt truncates reviewSummary to 1500 chars", () => {
-        const out = buildConvoPrompt({
-            reviewSummary: "x".repeat(3000),
-            productName: "Demo",
-            priorTurns: [],
-            newMessage: "hi",
-        });
-        expect(out.length).toBeLessThan(3000);
-    });
-    it("parseConvoReply parses bare JSON", () => {
-        const out = parseConvoReply('{"intent":"accept","reply":"Great!"}');
-        expect(out.intent).toBe("accept");
-        expect(out.reply).toBe("Great!");
-    });
-    it("parseConvoReply strips ```json code fence", () => {
-        const out = parseConvoReply('```json\n{"intent":"reject","reply":"fix it"}\n```');
-        expect(out.intent).toBe("reject");
-    });
-    it("parseConvoReply returns intent='discuss' + reply on malformed JSON", () => {
-        const out = parseConvoReply("not json at all");
-        expect(out.intent).toBe("discuss");
-        expect(out.reply.length).toBeGreaterThan(0);
-    });
-    it("parseConvoReply caps reply at 500 chars", () => {
-        const out = parseConvoReply(JSON.stringify({ intent: "discuss", reply: "x".repeat(800) }));
-        expect(out.reply.length).toBe(500);
-    });
-    it("parseConvoReply preserves unknown intent string for caller classification", () => {
-        const out = parseConvoReply(JSON.stringify({ intent: "maybe", reply: "..." }));
-        expect(out.intent).toBe("maybe");
-    });
-    it("buildConvoPrompt with empty priorTurns renders (none) placeholder", () => {
-        const out = buildConvoPrompt({
-            reviewSummary: "Done.",
-            productName: "Test",
-            priorTurns: [],
-            newMessage: "ok?",
-        });
-        expect(out).toContain("(none)");
-    });
-    it("parseConvoReply falls back to discuss when intent field is missing", () => {
-        const out = parseConvoReply(JSON.stringify({ reply: "hi" }));
-        expect(out.intent).toBe("discuss");
-    });
-    it("parseConvoReply falls back to FALLBACK_REPLY when reply field is missing", () => {
-        const out = parseConvoReply(JSON.stringify({ intent: "accept" }));
-        expect(out.reply.length).toBeGreaterThan(0);
-    });
-});
-//# sourceMappingURL=intent-prompt.test.js.map

package/dist/src/chat/__tests__/verdict-resolver.test.d.ts

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

package/dist/src/chat/__tests__/verdict-resolver.test.js

@@ -1,308 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { discordAwaitVerdict } from "../verdict-resolver.js";
-function makeClient(over = {}) {
-    return {
-        createChannel: vi.fn(),
-        getChannelMessages: vi.fn().mockResolvedValue([]),
-        postMessage: vi.fn().mockResolvedValue({ id: "bot-msg" }),
-        addChannelPermission: vi.fn(),
-        getCurrentUserId: vi.fn().mockResolvedValue("bot"),
-        listGuildChannels: vi.fn(),
-        ...over,
-    };
-}
-function msg(id, content, authorId = "user") {
-    return { id, content, author: { id: authorId, username: "u" }, timestamp: new Date().toISOString() };
-}
-describe("discordAwaitVerdict", () => {
-    let flowDir;
-    const runId = "r-v";
-    beforeEach(async () => {
-        flowDir = path.join(os.tmpdir(), `vr-${Math.random().toString(36).slice(2)}`);
-        await fs.mkdir(path.join(flowDir, "runs", runId), { recursive: true });
-    });
-    function baseArgs(over = {}) {
-        return {
-            flowDir,
-            runId,
-            phaseId: "phase-1",
-            sprintN: 1,
-            productSlug: "abc",
-            channelId: "c1",
-            client: makeClient(),
-            leader: { generate: vi.fn() },
-            capUsd: 10,
-            remainingUsd: async () => 5,
-            reviewSummary: "Sprint 1 complete.",
-            backoffDelays: [1, 1, 1],
-            pollIntervalMs: 1,
-            timeoutMs: 60_000,
-            sleep: async () => { },
-            now: () => Date.now(),
-            fallback: vi.fn().mockResolvedValue({ verdict: "accept" }),
-            ...over,
-        };
-    }
-    it("happy accept: single customer message classified accept", async () => {
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "OK accept it")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "accept", reply: "Great!" }),
-                costUsd: 0.01,
-            }),
-        };
-        const out = await discordAwaitVerdict(baseArgs({ client, leader }));
-        expect(out.verdict).toBe("accept");
-        expect(out.feedback).toBeUndefined();
-    });
-    it("reject returns customer message as feedback", async () => {
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "Please fix the auth flow")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "reject", reply: "noted" }),
-                costUsd: 0.01,
-            }),
-        };
-        const out = await discordAwaitVerdict(baseArgs({ client, leader }));
-        expect(out.verdict).toBe("reject");
-        expect(out.feedback).toContain("auth flow");
-    });
-    it("abort returns abort verdict", async () => {
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "Stop the whole thing")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "abort", reply: "OK stopping" }),
-                costUsd: 0.01,
-            }),
-        };
-        const out = await discordAwaitVerdict(baseArgs({ client, leader }));
-        expect(out.verdict).toBe("abort");
-    });
-    it("timeout returns abort with [timeout-24h]", async () => {
-        let nowVal = 0;
-        const client = makeClient({ getChannelMessages: vi.fn().mockResolvedValue([]) });
-        const out = await discordAwaitVerdict(baseArgs({
-            client,
-            timeoutMs: 100,
-            now: () => {
-                nowVal += 200;
-                return nowVal;
-            },
-        }));
-        expect(out.verdict).toBe("abort");
-        expect(out.feedback).toBe("[timeout-24h]");
-    });
-    it("VERDICT_FLOOR boundary aborts with budget-exhausted", async () => {
-        const out = await discordAwaitVerdict(baseArgs({
-            capUsd: 10,
-            remainingUsd: async () => 0.05,
-        }));
-        expect(out.verdict).toBe("abort");
-        expect(out.feedback).toBe("budget-exhausted");
-    });
-    it("cap_usd=0 immediately aborts", async () => {
-        const out = await discordAwaitVerdict(baseArgs({ capUsd: 0, remainingUsd: async () => 0 }));
-        expect(out.verdict).toBe("abort");
-        expect(out.feedback).toBe("budget-exhausted");
-    });
-    it("MAX_VERDICT_MESSAGES cap → fallback", async () => {
-        const messages = Array.from({ length: 25 }, (_, i) => msg(`m${i}`, "discuss please"));
-        const client = makeClient({
-            getChannelMessages: vi.fn().mockResolvedValueOnce(messages).mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "discuss", reply: "ok" }),
-                costUsd: 0.01,
-            }),
-        };
-        const fallback = vi.fn().mockResolvedValue({ verdict: "accept", feedback: "via-fallback" });
-        const out = await discordAwaitVerdict(baseArgs({ client, leader, fallback }));
-        expect(fallback).toHaveBeenCalled();
-        expect(out.feedback).toBe("via-fallback");
-    });
-    it("malformed JSON counts as discuss then continues", async () => {
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "something")])
-                .mockResolvedValueOnce([msg("m2", "I accept")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi
-                .fn()
-                .mockResolvedValueOnce({ content: "not json", costUsd: 0.01 })
-                .mockResolvedValueOnce({ content: JSON.stringify({ intent: "accept", reply: "OK" }), costUsd: 0.01 }),
-        };
-        const out = await discordAwaitVerdict(baseArgs({ client, leader }));
-        expect(out.verdict).toBe("accept");
-    });
-    it("unknown intent ×5 → fallback", async () => {
-        const messages = Array.from({ length: 5 }, (_, i) => msg(`m${i}`, "msg"));
-        const client = makeClient({
-            getChannelMessages: vi.fn().mockResolvedValueOnce(messages).mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "maybe", reply: "..." }),
-                costUsd: 0.01,
-            }),
-        };
-        const fallback = vi.fn().mockResolvedValue({ verdict: "reject", feedback: "via-fallback" });
-        const out = await discordAwaitVerdict(baseArgs({ client, leader, fallback }));
-        expect(fallback).toHaveBeenCalled();
-        expect(out.feedback).toBe("via-fallback");
-    });
-    it("leader transient failure ×3 → fallback", async () => {
-        const messages = Array.from({ length: 3 }, (_, i) => msg(`m${i}`, "msg"));
-        const client = makeClient({
-            getChannelMessages: vi.fn().mockResolvedValueOnce(messages).mockResolvedValue([]),
-        });
-        const leader = { generate: vi.fn().mockRejectedValue(new Error("net")) };
-        const fallback = vi.fn().mockResolvedValue({ verdict: "abort", feedback: "via-fallback" });
-        const _out = await discordAwaitVerdict(baseArgs({ client, leader, fallback }));
-        expect(fallback).toHaveBeenCalled();
-    });
-    it("404 on getChannelMessages → fallback", async () => {
-        const err = Object.assign(new Error("404"), { status: 404 });
-        const client = makeClient({ getChannelMessages: vi.fn().mockRejectedValue(err) });
-        const fallback = vi.fn().mockResolvedValue({ verdict: "accept", feedback: "via-fallback" });
-        const _out = await discordAwaitVerdict(baseArgs({ client, fallback }));
-        expect(fallback).toHaveBeenCalled();
-    });
-    it("filters out bot's own messages", async () => {
-        const client = makeClient({
-            getCurrentUserId: vi.fn().mockResolvedValue("bot"),
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "I am bot", "bot"), msg("m2", "I accept", "user")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "accept", reply: "ok" }),
-                costUsd: 0.01,
-            }),
-        };
-        const out = await discordAwaitVerdict(baseArgs({ client, leader }));
-        expect(leader.generate).toHaveBeenCalledOnce();
-        expect(out.verdict).toBe("accept");
-    });
-    it("persists poll cursor in state.md", async () => {
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m99", "I accept")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "accept", reply: "ok" }),
-                costUsd: 0.01,
-            }),
-        };
-        await discordAwaitVerdict(baseArgs({ client, leader }));
-        const stateFile = path.join(flowDir, "runs", runId, "state.md");
-        const content = await fs.readFile(stateFile, "utf8");
-        expect(content).toContain("Discord Poll Cursor");
-        expect(content).toContain("m99");
-    });
-    it("cursor advance is AFTER bot reply post (resume safety)", async () => {
-        const order = [];
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "I accept")])
-                .mockResolvedValue([]),
-            postMessage: vi.fn().mockImplementation(async () => {
-                order.push("postReply");
-                return { id: "bot" };
-            }),
-        });
-        const leader = {
-            generate: vi.fn().mockImplementation(async () => {
-                order.push("leaderCall");
-                return { content: JSON.stringify({ intent: "accept", reply: "ok" }), costUsd: 0.01 };
-            }),
-        };
-        await discordAwaitVerdict(baseArgs({ client, leader }));
-        expect(order).toEqual(["leaderCall", "postReply"]);
-    });
-    it("403 on getChannelMessages → fallback", async () => {
-        const err = Object.assign(new Error("403"), { status: 403 });
-        const client = makeClient({ getChannelMessages: vi.fn().mockRejectedValue(err) });
-        const fallback = vi.fn().mockResolvedValue({ verdict: "reject", feedback: "via-fallback" });
-        const out = await discordAwaitVerdict(baseArgs({ client, fallback }));
-        expect(fallback).toHaveBeenCalled();
-        expect(out.verdict).toBe("reject");
-    });
-    it("cursor update replaces existing entry (not appended)", async () => {
-        // Two verdicts on different sprints, cursor for phase-1/sprint-1 gets updated
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m10", "I accept")])
-                .mockResolvedValueOnce([msg("m20", "I accept")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockResolvedValue({
-                content: JSON.stringify({ intent: "accept", reply: "ok" }),
-                costUsd: 0.01,
-            }),
-        };
-        // First run
-        await discordAwaitVerdict(baseArgs({ client, leader }));
-        // Second run same phase/sprint - cursor entry should be updated (same idx)
-        const client2 = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m20", "I accept")])
-                .mockResolvedValue([]),
-        });
-        await discordAwaitVerdict(baseArgs({ client: client2, leader }));
-        const stateFile = path.join(flowDir, "runs", runId, "state.md");
-        const content = await fs.readFile(stateFile, "utf8");
-        // Should have exactly one cursor entry, not two
-        const matches = content.match(/"phaseId"/g);
-        expect(matches?.length).toBe(1);
-    });
-    it("budget-exhausted during poll loop aborts with feedback", async () => {
-        let remaining = 10;
-        const client = makeClient({
-            getChannelMessages: vi
-                .fn()
-                .mockResolvedValueOnce([msg("m1", "discuss")])
-                .mockResolvedValue([]),
-        });
-        const leader = {
-            generate: vi.fn().mockImplementation(async () => {
-                remaining = 0; // exhaust budget after first process
-                return { content: JSON.stringify({ intent: "discuss", reply: "ok" }), costUsd: 0.01 };
-            }),
-        };
-        const out = await discordAwaitVerdict(baseArgs({ client, leader, capUsd: 10, remainingUsd: async () => remaining }));
-        expect(out.verdict).toBe("abort");
-        expect(out.feedback).toBe("budget-exhausted");
-    });
-});
-//# sourceMappingURL=verdict-resolver.test.js.map

package/dist/src/cli/__tests__/bw-vault.test.d.ts

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

package/dist/src/cli/__tests__/bw-vault.test.js

@@ -1,87 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { writeBwSecureNote } from "../bw-vault.js";
-function makeRunner(scripted) {
-    const calls = [];
-    let i = 0;
-    const runner = (cmd, args, input) => {
-        calls.push({ cmd, args, input });
-        const next = scripted[i++] ?? { status: 0, stdout: "", stderr: "" };
-        return {
-            pid: 0,
-            output: [],
-            stdout: next.stdout ?? "",
-            stderr: next.stderr ?? "",
-            status: next.status,
-            signal: null,
-        };
-    };
-    return { runner, calls };
-}
-describe("writeBwSecureNote", () => {
-    let origSession;
-    beforeEach(() => {
-        origSession = process.env.BW_SESSION;
-        process.env.BW_SESSION = "fake-session-token";
-    });
-    afterEach(() => {
-        if (origSession === undefined)
-            delete process.env.BW_SESSION;
-        else
-            process.env.BW_SESSION = origSession;
-    });
-    it("creates a new Secure Note when item does not exist", async () => {
-        const { runner, calls } = makeRunner([
-            { status: 0, stdout: "2026.4.0\n" }, // bw --version
-            { status: 0, stdout: '{"status":"unlocked"}' }, // bw status
-            { status: 0, stdout: "[]" }, // bw list items (empty)
-            { status: 0, stdout: "ZW5jb2RlZA==" }, // bw encode
-            { status: 0, stdout: '{"id":"new-uuid"}' }, // bw create item
-            { status: 0, stdout: "Syncing complete." }, // bw sync
-        ]);
-        const res = await writeBwSecureNote("muonroi-cli/tavily", "tvly-test-1234567890", { runner });
-        expect(res).toEqual({ ok: true, action: "created" });
-        expect(calls[3].cmd).toBe("bw");
-        expect(calls[3].args[0]).toBe("encode");
-        expect(calls[3].input).toContain("tvly-test-1234567890");
-        expect(calls[4].args.slice(0, 3)).toEqual(["create", "item", "ZW5jb2RlZA=="]);
-    });
-    it("updates an existing item rather than creating a duplicate", async () => {
-        const { runner, calls } = makeRunner([
-            { status: 0, stdout: "2026.4.0\n" },
-            { status: 0, stdout: '{"status":"unlocked"}' },
-            {
-                status: 0,
-                stdout: JSON.stringify([{ id: "existing-uuid", name: "muonroi-cli/tavily", notes: "old-key", type: 2 }]),
-            },
-            { status: 0, stdout: "ZW5jb2RlZA==" },
-            { status: 0, stdout: '{"id":"existing-uuid"}' }, // bw edit
-            { status: 0, stdout: "Syncing complete." },
-        ]);
-        const res = await writeBwSecureNote("muonroi-cli/tavily", "tvly-new-1234567890", { runner });
-        expect(res).toEqual({ ok: true, action: "updated" });
-        expect(calls[4].args.slice(0, 3)).toEqual(["edit", "item", "existing-uuid"]);
-    });
-    it("returns ok:false when bw is not installed", async () => {
-        const { runner } = makeRunner([{ status: 127, stderr: "command not found" }]);
-        const res = await writeBwSecureNote("muonroi-cli/tavily", "tvly-x", { runner });
-        expect(res.ok).toBe(false);
-        expect(res.error).toMatch(/Bitwarden CLI/);
-    });
-    it("returns ok:false when BW_SESSION is missing", async () => {
-        delete process.env.BW_SESSION;
-        const { runner } = makeRunner([{ status: 0, stdout: "2026.4.0" }]);
-        const res = await writeBwSecureNote("muonroi-cli/tavily", "tvly-x", { runner });
-        expect(res.ok).toBe(false);
-        expect(res.error).toMatch(/BW_SESSION/);
-    });
-    it("returns ok:false when vault is locked", async () => {
-        const { runner } = makeRunner([
-            { status: 0, stdout: "2026.4.0" },
-            { status: 0, stdout: '{"status":"locked"}' },
-        ]);
-        const res = await writeBwSecureNote("muonroi-cli/tavily", "tvly-x", { runner });
-        expect(res.ok).toBe(false);
-        expect(res.error).toMatch(/not unlocked/i);
-    });
-});
-//# sourceMappingURL=bw-vault.test.js.map

package/dist/src/cli/__tests__/keys-bundle.test.d.ts

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

package/dist/src/cli/__tests__/keys-bundle.test.js

@@ -1,40 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { decryptBundle, encryptBundle } from "../keys-bundle.js";
-describe("keys-bundle round-trip", () => {
-    const sample = {
-        providers: {
-            deepseek: "sk-mock-deepseek-test-fixture-only",
-            siliconflow: "sk-mock-siliconflow-test-fixture-only",
-        },
-    };
-    test("encrypts and decrypts back to identical payload", () => {
-        const bundle = encryptBundle(sample, "correct-horse-battery");
-        const restored = decryptBundle(bundle, "correct-horse-battery");
-        expect(restored).toEqual(sample);
-    });
-    test("each encryption produces unique salt+iv+ct", () => {
-        const a = encryptBundle(sample, "passphrase-aaa");
-        const b = encryptBundle(sample, "passphrase-aaa");
-        expect(a.salt).not.toBe(b.salt);
-        expect(a.iv).not.toBe(b.iv);
-        expect(a.ct).not.toBe(b.ct);
-    });
-    test("wrong passphrase throws decryption error", () => {
-        const bundle = encryptBundle(sample, "correct-passphrase");
-        expect(() => decryptBundle(bundle, "wrong-passphrase")).toThrow(/Decryption failed/);
-    });
-    test("rejects passphrase shorter than 8 chars", () => {
-        expect(() => encryptBundle(sample, "short")).toThrow(/at least 8/);
-    });
-    test("rejects unsupported bundle version", () => {
-        const bundle = encryptBundle(sample, "passphrase-xyz");
-        const tampered = { ...bundle, v: 2 };
-        expect(() => decryptBundle(tampered, "passphrase-xyz")).toThrow(/Unsupported bundle version/);
-    });
-    test("tampered ciphertext fails auth", () => {
-        const bundle = encryptBundle(sample, "passphrase-xyz");
-        const tampered = { ...bundle, ct: Buffer.from("not-the-real-ciphertext-here").toString("base64") };
-        expect(() => decryptBundle(tampered, "passphrase-xyz")).toThrow(/Decryption failed/);
-    });
-});
-//# sourceMappingURL=keys-bundle.test.js.map

package/dist/src/cli/__tests__/share-cmd.test.d.ts

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