muonroi-cli 1.8.0 → 1.8.3

package/dist/src/headless/__tests__/council-answers.test.js

@@ -1,251 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createCouncilAutoAnswerer, createHeadlessCouncilAutoAnswerer, handleCouncilChunk, parseCouncilAnswersFile, } from "../council-answers.js";
-function q(over) {
-    return {
-        questionId: "qid",
-        question: "?",
-        isRequired: false,
-        ...over,
-    };
-}
-describe("parseCouncilAnswersFile", () => {
-    it("parses a valid object with phase queues + preflightApprove", () => {
-        const out = parseCouncilAnswersFile(JSON.stringify({
-            clarify: ["python", "mongo"],
-            "post-debate": ["generate_plan"],
-            preflightApprove: false,
-        }));
-        expect(out.clarify).toEqual(["python", "mongo"]);
-        expect(out["post-debate"]).toEqual(["generate_plan"]);
-        expect(out.preflightApprove).toBe(false);
-    });
-    it("rejects non-object root", () => {
-        expect(() => parseCouncilAnswersFile(JSON.stringify(["x"]))).toThrow(/object/);
-        expect(() => parseCouncilAnswersFile(JSON.stringify(42))).toThrow(/object/);
-    });
-    it("rejects non-string entries in a phase queue", () => {
-        expect(() => parseCouncilAnswersFile(JSON.stringify({ clarify: [1, 2] }))).toThrow(/clarify/);
-    });
-    it("rejects non-boolean preflightApprove", () => {
-        expect(() => parseCouncilAnswersFile(JSON.stringify({ preflightApprove: "yes" }))).toThrow(/preflightApprove/);
-    });
-    it("accepts an empty object", () => {
-        expect(parseCouncilAnswersFile("{}")).toEqual({});
-    });
-});
-describe("createCouncilAutoAnswerer", () => {
-    it("returns null when neither enabled nor file is provided", () => {
-        expect(createCouncilAutoAnswerer({ enabled: false })).toBeNull();
-    });
-    it("--yes alone picks defaultIndex value", () => {
-        const a = createCouncilAutoAnswerer({ enabled: true });
-        expect(a).not.toBeNull();
-        const answer = a.answerQuestion(q({
-            phase: "post-debate",
-            defaultIndex: 1,
-            options: [
-                { label: "A", value: "a", kind: "choice" },
-                { label: "B", value: "b", kind: "choice" },
-            ],
-        }));
-        expect(answer).toBe("b");
-    });
-    it("falls back to first option when defaultIndex is out of range", () => {
-        const a = createCouncilAutoAnswerer({ enabled: true });
-        const answer = a.answerQuestion(q({
-            phase: "post-debate",
-            defaultIndex: 99,
-            options: [
-                { label: "A", value: "a", kind: "choice" },
-                { label: "B", value: "b", kind: "choice" },
-            ],
-        }));
-        expect(answer).toBe("a");
-    });
-    it("returns empty string for freetext questions with no options", () => {
-        const a = createCouncilAutoAnswerer({ enabled: true });
-        expect(a.answerQuestion(q({ phase: "clarify" }))).toBe("");
-    });
-    it("scripted answers consume FIFO per phase", () => {
-        const a = createCouncilAutoAnswerer({
-            enabled: false,
-            file: { clarify: ["first", "second"] },
-        });
-        expect(a.answerQuestion(q({ phase: "clarify" }))).toBe("first");
-        expect(a.answerQuestion(q({ phase: "clarify" }))).toBe("second");
-        // Queue exhausted → fall back to default (empty string for freetext).
-        expect(a.answerQuestion(q({ phase: "clarify" }))).toBe("");
-    });
-    it("scripted queue for one phase does not bleed into another", () => {
-        const a = createCouncilAutoAnswerer({
-            enabled: false,
-            file: { clarify: ["c1"], "post-debate": ["pd1"] },
-        });
-        expect(a.answerQuestion(q({ phase: "post-debate" }))).toBe("pd1");
-        expect(a.answerQuestion(q({ phase: "clarify" }))).toBe("c1");
-    });
-    it("preflight approval defaults to true", () => {
-        const a = createCouncilAutoAnswerer({ enabled: true });
-        expect(a.approvePreflight()).toBe(true);
-    });
-    it("preflight approval honors preflightApprove: false", () => {
-        const a = createCouncilAutoAnswerer({
-            enabled: false,
-            file: { preflightApprove: false },
-        });
-        expect(a.approvePreflight()).toBe(false);
-    });
-    it("preserves caller's file by deep-copying queues", () => {
-        const file = { clarify: ["a", "b"] };
-        const a = createCouncilAutoAnswerer({ enabled: false, file });
-        a.answerQuestion(q({ phase: "clarify" }));
-        // The caller's queue must remain intact.
-        expect(file.clarify).toEqual(["a", "b"]);
-    });
-});
-describe("createHeadlessCouncilAutoAnswerer (headless never hangs)", () => {
-    it("ALWAYS returns an active answerer even with no file and no --yes", () => {
-        // Regression: previously headless gated the answerer on `--yes`, so a prompt
-        // that triggered council without --yes left the responder promise unresolved
-        // and the process hung forever (0 output). Headless has no TUI to answer, so
-        // the answerer must always be present and auto-proceed with the recommended
-        // (defaultIndex) option.
-        const a = createHeadlessCouncilAutoAnswerer({});
-        expect(a).not.toBeNull();
-        const answer = a.answerQuestion(q({
-            phase: "post-debate",
-            defaultIndex: 1,
-            options: [
-                { label: "A", value: "a", kind: "choice" },
-                { label: "B", value: "b", kind: "choice" },
-            ],
-        }));
-        expect(answer).toBe("b"); // recommended (defaultIndex) option
-        expect(a.approvePreflight()).toBe(true);
-    });
-    it("still honors a scripted --council-answers file", () => {
-        const a = createHeadlessCouncilAutoAnswerer({ file: { clarify: ["mongo"] } });
-        expect(a.answerQuestion(q({ phase: "clarify" }))).toBe("mongo");
-    });
-});
-describe("handleCouncilChunk (interception wiring)", () => {
-    function makeSink() {
-        return {
-            respondToQuestion: vi.fn(),
-            respondToPreflight: vi.fn(),
-        };
-    }
-    it("returns null and is a no-op when answerer is null", () => {
-        const sink = makeSink();
-        const out = handleCouncilChunk({ type: "council_question", councilQuestion: q({ phase: "clarify" }) }, null, sink);
-        expect(out).toBeNull();
-        expect(sink.respondToQuestion).not.toHaveBeenCalled();
-    });
-    it("returns null for non-askcard chunks", () => {
-        const sink = makeSink();
-        const a = createCouncilAutoAnswerer({ enabled: true });
-        const out = handleCouncilChunk({ type: "content" }, a, sink);
-        expect(out).toBeNull();
-        expect(sink.respondToQuestion).not.toHaveBeenCalled();
-        expect(sink.respondToPreflight).not.toHaveBeenCalled();
-    });
-    it("calls respondToQuestion with the resolved answer for a clarify chunk", () => {
-        const sink = makeSink();
-        const a = createCouncilAutoAnswerer({
-            enabled: false,
-            file: { clarify: ["mongo"] },
-        });
-        const audit = handleCouncilChunk({
-            type: "council_question",
-            councilQuestion: q({ phase: "clarify", questionId: "q-1" }),
-        }, a, sink);
-        expect(sink.respondToQuestion).toHaveBeenCalledWith("q-1", "mongo");
-        expect(audit).toContain("clarify → mongo");
-    });
-    it("calls respondToQuestion with defaultIndex value when --yes only", () => {
-        const sink = makeSink();
-        const a = createCouncilAutoAnswerer({ enabled: true });
-        handleCouncilChunk({
-            type: "council_question",
-            councilQuestion: q({
-                phase: "post-debate",
-                questionId: "q-2",
-                defaultIndex: 0,
-                options: [
-                    { label: "Continue", value: "continue", kind: "choice" },
-                    { label: "Stop", value: "stop", kind: "choice" },
-                ],
-            }),
-        }, a, sink);
-        expect(sink.respondToQuestion).toHaveBeenCalledWith("q-2", "continue");
-    });
-    it("approves preflight chunks by default", () => {
-        const sink = makeSink();
-        const a = createCouncilAutoAnswerer({ enabled: true });
-        const audit = handleCouncilChunk({ type: "council_preflight", councilPreflight: { preflightId: "pf-1" } }, a, sink);
-        expect(sink.respondToPreflight).toHaveBeenCalledWith("pf-1", true);
-        expect(audit).toContain("approve");
-    });
-    it("rejects preflight when file says preflightApprove: false", () => {
-        const sink = makeSink();
-        const a = createCouncilAutoAnswerer({
-            enabled: false,
-            file: { preflightApprove: false },
-        });
-        handleCouncilChunk({ type: "council_preflight", councilPreflight: { preflightId: "pf-2" } }, a, sink);
-        expect(sink.respondToPreflight).toHaveBeenCalledWith("pf-2", false);
-    });
-    it("replays the 1a8fb4be3bc3 session via a scripted file", () => {
-        // Simulates the 3 clarify answers from chat-export-1a8fb4be3bc3.txt
-        // plus a typical research-skip "no" + post-debate "continue" + preflight approve.
-        const sink = makeSink();
-        const a = createCouncilAutoAnswerer({
-            enabled: true,
-            file: {
-                clarify: [
-                    "Browser extension (Chrome/Brave/Edge compatible)",
-                    "Google Cloud Translation API (paid, reliable)",
-                    "Auto-show tooltip/popup immediately on text highlight",
-                ],
-                // FIFO across all post-debate askcards: research-skip → "no", then post-debate continue
-                "post-debate": ["no", "continue"],
-            },
-        });
-        const order = [];
-        const fakeStream = [
-            { type: "council_question", councilQuestion: q({ phase: "clarify", questionId: "c1" }) },
-            { type: "council_question", councilQuestion: q({ phase: "clarify", questionId: "c2" }) },
-            { type: "council_question", councilQuestion: q({ phase: "clarify", questionId: "c3" }) },
-            // research skip → no scripted answer for "post-debate" yet; --yes default kicks in (option 0 = "no")
-            {
-                type: "council_question",
-                councilQuestion: q({
-                    phase: "post-debate",
-                    questionId: "research-skip",
-                    defaultIndex: 0,
-                    options: [
-                        { label: "No — run research", value: "no", kind: "choice" },
-                        { label: "Yes — skip", value: "yes", kind: "choice" },
-                    ],
-                }),
-            },
-            { type: "council_preflight", councilPreflight: { preflightId: "pf-1" } },
-            // post-debate scripted "continue"
-            { type: "council_question", councilQuestion: q({ phase: "post-debate", questionId: "pd-1" }) },
-        ];
-        for (const chunk of fakeStream) {
-            handleCouncilChunk(chunk, a, sink);
-        }
-        for (const call of sink.respondToQuestion.mock.calls)
-            order.push(call[1]);
-        expect(order).toEqual([
-            "Browser extension (Chrome/Brave/Edge compatible)",
-            "Google Cloud Translation API (paid, reliable)",
-            "Auto-show tooltip/popup immediately on text highlight",
-            "no",
-            "continue",
-        ]);
-        expect(sink.respondToPreflight).toHaveBeenCalledWith("pf-1", true);
-    });
-});
-//# sourceMappingURL=council-answers.test.js.map

package/dist/src/headless/output.test.d.ts

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

package/dist/src/headless/output.test.js

@@ -1,239 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createHeadlessJsonlEmitter, createHeadlessTextEmitter, formatStructuredResponseText, isHeadlessOutputFormat, renderHeadlessChunk, renderHeadlessPrelude, } from "./output.js";
-function toolCall(name) {
-    return {
-        id: "tc-1",
-        type: "function",
-        function: {
-            name,
-            arguments: "{}",
-        },
-    };
-}
-function expectSessionAndTimestamp(e, sessionId) {
-    if (sessionId !== undefined) {
-        expect(e.sessionID).toBe(sessionId);
-    }
-    else {
-        expect(e.sessionID).toBeUndefined();
-    }
-    expect(typeof e.timestamp).toBe("number");
-}
-describe("headless output helpers", () => {
-    it("recognizes supported output formats", () => {
-        expect(isHeadlessOutputFormat("text")).toBe(true);
-        expect(isHeadlessOutputFormat("json")).toBe(true);
-        expect(isHeadlessOutputFormat("xml")).toBe(false);
-    });
-    it("renders the text prelude with status on stderr (stdout stays pure for piping)", () => {
-        // VERIFY F3: spinner + session id are progress UX, not the reply — both go
-        // to stderr so `--format text` stdout contains only the model's answer.
-        expect(renderHeadlessPrelude("text", "session-123")).toEqual({
-            stderr: "⏳ Processing...\nSession: session-123\n",
-        });
-    });
-    it("suppresses the prelude in json mode", () => {
-        expect(renderHeadlessPrelude("json", "session-123")).toEqual({});
-    });
-    it("renders tool calls for text mode", () => {
-        const chunk = {
-            type: "tool_calls",
-            toolCalls: [toolCall("bash"), toolCall("read_file")],
-        };
-        expect(renderHeadlessChunk(chunk)).toEqual({
-            stderr: "\u001b[33m▸ bash\u001b[0m\n\u001b[33m▸ read_file\u001b[0m\n",
-        });
-    });
-    it("renders tool results for text mode", () => {
-        const chunk = {
-            type: "tool_result",
-            toolCall: toolCall("bash"),
-            toolResult: {
-                success: false,
-                output: "failed",
-            },
-        };
-        expect(renderHeadlessChunk(chunk)).toEqual({
-            stderr: "\u001b[31m✗ bash\u001b[0m\n",
-        });
-    });
-    it("renders generated media paths in text mode tool results", () => {
-        const chunk = {
-            type: "tool_result",
-            toolCall: toolCall("generate_image"),
-            toolResult: {
-                success: true,
-                output: "Generated 1 image.",
-                media: [{ kind: "image", path: "/tmp/generated.png", url: "https://example.com/generated.png" }],
-            },
-        };
-        expect(renderHeadlessChunk(chunk)).toEqual({
-            stderr: "\u001b[32m▸ generate_image\u001b[0m\n  /tmp/generated.png (https://example.com/generated.png)\n",
-        });
-    });
-    it("emits semantic JSONL for a single step with text and tool (json emitter)", () => {
-        const sessionId = "jsonl-test-session";
-        const tc = toolCall("bash");
-        const { observer, consumeChunk, flush } = createHeadlessJsonlEmitter(sessionId);
-        let combined = "";
-        observer.onStepStart?.({ stepNumber: 1, timestamp: 100 });
-        combined += consumeChunk({ type: "content", content: "hello" }).stdout ?? "";
-        observer.onToolStart?.({ toolCall: tc, timestamp: 110 });
-        combined +=
-            consumeChunk({
-                type: "tool_calls",
-                toolCalls: [tc],
-            }).stdout ?? "";
-        observer.onToolFinish?.({
-            toolCall: tc,
-            toolResult: { success: true, output: "ok" },
-            timestamp: 130,
-        });
-        combined +=
-            consumeChunk({
-                type: "tool_result",
-                toolCall: tc,
-                toolResult: { success: true, output: "ok" },
-            }).stdout ?? "";
-        observer.onStepFinish?.({
-            stepNumber: 1,
-            timestamp: 200,
-            finishReason: "stop",
-            usage: { inputTokens: 1, outputTokens: 2, totalTokens: 3 },
-        });
-        combined += flush().stdout ?? "";
-        const events = combined
-            .trim()
-            .split("\n")
-            .map((l) => JSON.parse(l));
-        expect(events.map((e) => e.type)).toEqual(["step_start", "text", "tool_use", "step_finish"]);
-        expectSessionAndTimestamp(events[0], sessionId);
-        expect(events[0]).toMatchObject({ type: "step_start", stepNumber: 1, timestamp: 100 });
-        expectSessionAndTimestamp(events[1], sessionId);
-        expect(events[1]).toMatchObject({ type: "text", stepNumber: 1, text: "hello" });
-        expectSessionAndTimestamp(events[2], sessionId);
-        expect(events[2]).toMatchObject({
-            type: "tool_use",
-            stepNumber: 1,
-            timestamp: 130,
-            timing: { startedAt: 110, finishedAt: 130, durationMs: 20 },
-        });
-        expectSessionAndTimestamp(events[3], sessionId);
-        expect(events[3]).toMatchObject({
-            type: "step_finish",
-            stepNumber: 1,
-            finishReason: "stop",
-            usage: { inputTokens: 1, outputTokens: 2, totalTokens: 3 },
-            timestamp: 200,
-        });
-    });
-    it("does not emit empty text events at step_finish when tools already flushed assistant text", () => {
-        const sessionId = "sess-2";
-        const tc = toolCall("bash");
-        const { observer, consumeChunk, flush } = createHeadlessJsonlEmitter(sessionId);
-        let combined = "";
-        observer.onStepStart?.({ stepNumber: 0, timestamp: 1 });
-        combined += consumeChunk({ type: "content", content: "x" }).stdout ?? "";
-        observer.onToolStart?.({ toolCall: tc, timestamp: 5 });
-        combined += consumeChunk({ type: "tool_calls", toolCalls: [tc] }).stdout ?? "";
-        observer.onToolFinish?.({
-            toolCall: tc,
-            toolResult: { success: true, output: "y" },
-            timestamp: 8,
-        });
-        combined +=
-            consumeChunk({
-                type: "tool_result",
-                toolCall: tc,
-                toolResult: { success: true, output: "y" },
-            }).stdout ?? "";
-        observer.onStepFinish?.({
-            stepNumber: 0,
-            timestamp: 2,
-            finishReason: "tool-calls",
-            usage: {},
-        });
-        combined += flush().stdout ?? "";
-        const events = combined
-            .trim()
-            .split("\n")
-            .map((l) => JSON.parse(l));
-        expect(events.filter((e) => e.type === "text").every((e) => e.text.length > 0)).toBe(true);
-        expect(events.map((e) => e.type)).toEqual(["step_start", "text", "tool_use", "step_finish"]);
-        for (const e of events) {
-            expectSessionAndTimestamp(e, sessionId);
-        }
-    });
-    it("emits error events from stream chunks", () => {
-        const sessionId = "err-session";
-        const { consumeChunk } = createHeadlessJsonlEmitter(sessionId);
-        const w = consumeChunk({ type: "error", content: "boom" });
-        const parsed = JSON.parse(w.stdout?.trim() ?? "{}");
-        expect(parsed).toMatchObject({
-            type: "error",
-            message: "boom",
-        });
-        expectSessionAndTimestamp(parsed, sessionId);
-    });
-    // Regression backstop for G5: a respond_* terminal answer arrives ONLY as a
-    // `structured_response` chunk. Both headless renderers used to drop it
-    // (no-op default branch), so `--format text` produced empty stdout and
-    // `--format json` emitted no answer payload on a preamble-free turn.
-    describe("structured_response (respond_* terminal answer)", () => {
-        const generalChunk = {
-            type: "structured_response",
-            structuredResponse: { taskType: "general", data: { response: "The answer." } },
-        };
-        it("renderHeadlessChunk renders the answer to stdout (no longer dropped)", () => {
-            const w = renderHeadlessChunk(generalChunk);
-            expect(w.stdout).toBe("The answer.\n");
-            expect(w.stderr).toBeUndefined();
-        });
-        it("formatStructuredResponseText lays out each taskType as flat text", () => {
-            expect(formatStructuredResponseText({
-                taskType: "analyze",
-                data: { findings: [{ text: "Bug X", evidence: "file:1", severity: "high" }] },
-            })).toBe("[HIGH] Bug X\n  evidence: file:1");
-            expect(formatStructuredResponseText({
-                taskType: "plan",
-                data: { steps: [{ action: "Do A", criterion: "A done", rationale: "because" }] },
-            })).toBe("1. Do A\n   done when: A done\n   why: because");
-            // Unknown taskType falls back to a primary text field, then JSON.
-            expect(formatStructuredResponseText({ taskType: "mystery", data: { summary: "hi" } })).toBe("hi");
-            expect(formatStructuredResponseText({ taskType: "mystery", data: { n: 1 } })).toBe('{\n  "n": 1\n}');
-        });
-        it("text emitter: a structured answer SUPERSEDES leaked preamble content (no duplicate)", () => {
-            const e = createHeadlessTextEmitter();
-            // Model leaks the raw answer as content, then delivers it via respond_*.
-            expect(e.consumeChunk({ type: "content", content: '```json\n{"x":1}\n```' }).stdout).toBeUndefined();
-            const out = e.consumeChunk(generalChunk).stdout;
-            expect(out).toBe("The answer.\n");
-            // Nothing buffered remains to flush — the answer is not printed twice.
-            expect(e.flush().stdout).toBeUndefined();
-        });
-        it("text emitter: a normal content-only turn flushes its buffered answer", () => {
-            const e = createHeadlessTextEmitter();
-            expect(e.consumeChunk({ type: "content", content: "PONG" }).stdout).toBeUndefined();
-            expect(e.consumeChunk({ type: "done" }).stdout).toBeUndefined();
-            expect(e.flush().stdout).toBe("PONG\n");
-        });
-        it("text emitter: tool/error progress still streams to stderr immediately", () => {
-            const e = createHeadlessTextEmitter();
-            const w = e.consumeChunk({ type: "tool_calls", toolCalls: [toolCall("bash")] });
-            expect(w.stderr).toContain("bash");
-            expect(w.stdout).toBeUndefined();
-        });
-        it("json emitter: emits a typed structured_response event carrying the payload", () => {
-            const { consumeChunk } = createHeadlessJsonlEmitter("sess-sr");
-            const out = consumeChunk(generalChunk).stdout ?? "";
-            const events = out
-                .trim()
-                .split("\n")
-                .map((l) => JSON.parse(l));
-            const sr = events.find((ev) => ev.type === "structured_response");
-            expect(sr).toMatchObject({ type: "structured_response", taskType: "general", data: { response: "The answer." } });
-            expectSessionAndTimestamp(sr, "sess-sr");
-        });
-    });
-});
-//# sourceMappingURL=output.test.js.map

package/dist/src/lsp/builtins.test.d.ts

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

package/dist/src/lsp/builtins.test.js

@@ -1,112 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "fs/promises";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-vi.mock("./npm-cache", () => ({
-    lspNpmWhich: vi.fn(async () => null),
-}));
-const { createRuntimeLspDefinitions } = await import("./builtins.js");
-const tempDirs = [];
-afterEach(async () => {
-    await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 })));
-});
-describe("createRuntimeLspDefinitions", () => {
-    it("includes all built-in definitions when no overrides are set", () => {
-        const defs = createRuntimeLspDefinitions("/tmp", {
-            enabled: true,
-            tool: true,
-            autoInstall: false,
-            startupTimeoutMs: 5000,
-            requestTimeoutMs: 5000,
-            diagnosticsDebounceMs: 0,
-            builtins: {},
-            servers: [],
-        });
-        const ids = defs.map((d) => d.id);
-        expect(ids).toContain("typescript");
-        expect(ids).toContain("pyright");
-        expect(ids).toContain("gopls");
-        expect(ids).toContain("rust-analyzer");
-        expect(ids).toContain("csharp-ls");
-    });
-    it("maps the .cs extension to the csharp-ls built-in (csharp languageId)", () => {
-        const defs = createRuntimeLspDefinitions("/tmp", {
-            enabled: true,
-            tool: true,
-            autoInstall: false,
-            startupTimeoutMs: 5000,
-            requestTimeoutMs: 5000,
-            diagnosticsDebounceMs: 0,
-            builtins: {},
-            servers: [],
-        });
-        const csharp = defs.find((d) => d.id === "csharp-ls");
-        expect(csharp).toBeDefined();
-        expect(csharp.extensions).toContain(".cs");
-        expect(csharp.languageIds[".cs"]).toBe("csharp");
-    });
-    it("excludes a built-in when disabled via settings", () => {
-        const defs = createRuntimeLspDefinitions("/tmp", {
-            enabled: true,
-            tool: true,
-            autoInstall: false,
-            startupTimeoutMs: 5000,
-            requestTimeoutMs: 5000,
-            diagnosticsDebounceMs: 0,
-            builtins: {
-                typescript: { enabled: false },
-            },
-            servers: [],
-        });
-        const ids = defs.map((d) => d.id);
-        expect(ids).not.toContain("typescript");
-        expect(ids).toContain("pyright");
-    });
-    it("includes custom server definitions", () => {
-        const defs = createRuntimeLspDefinitions("/tmp", {
-            enabled: true,
-            tool: true,
-            autoInstall: false,
-            startupTimeoutMs: 5000,
-            requestTimeoutMs: 5000,
-            diagnosticsDebounceMs: 0,
-            builtins: {},
-            servers: [
-                {
-                    id: "custom-lsp",
-                    command: "custom-server",
-                    extensions: [".xyz"],
-                },
-            ],
-        });
-        const custom = defs.find((d) => d.id === "custom-lsp");
-        expect(custom).toBeDefined();
-        expect(custom.extensions).toEqual([".xyz"]);
-    });
-    it("resolves root using nearest marker from the file upward", async () => {
-        const workspace = await createTempWorkspace();
-        const nestedDir = path.join(workspace, "packages", "core", "src");
-        await mkdir(nestedDir, { recursive: true });
-        await writeFile(path.join(workspace, "packages", "core", "tsconfig.json"), "{}");
-        const defs = createRuntimeLspDefinitions(workspace, {
-            enabled: true,
-            tool: true,
-            autoInstall: false,
-            startupTimeoutMs: 5000,
-            requestTimeoutMs: 5000,
-            diagnosticsDebounceMs: 0,
-            builtins: {},
-            servers: [],
-        });
-        const tsDef = defs.find((d) => d.id === "typescript");
-        const root = await tsDef.resolveRoot(path.join(nestedDir, "index.ts"), workspace);
-        expect(root).toBe(path.join(workspace, "packages", "core"));
-    });
-});
-async function createTempWorkspace() {
-    const root = await mkdtemp(path.join(os.tmpdir(), "muonroi-lsp-builtins-"));
-    tempDirs.push(root);
-    await mkdir(path.join(root, ".git"), { recursive: true });
-    return root;
-}
-//# sourceMappingURL=builtins.test.js.map

package/dist/src/lsp/client-normalize.test.d.ts

@@ -1,12 +0,0 @@
-/**
- * src/lsp/client-normalize.test.ts
- *
- * Regression guard for the Windows diagnostics-cache key mismatch: the LSP
- * client stores publishDiagnostics under normalizeUriPath(uri) (a LOWERCASE
- * drive, decoded from `file:///c%3A/…`) but retrieves under
- * normalizeFsPath(path.resolve(...)) (the cwd's UPPERCASE drive). Without
- * canonicalizing the drive letter the keys never matched, so diagnostics were
- * permanently [] on Windows — silently breaking write-time LSP feedback AND the
- * commit gate. normalizeFsPath must produce the SAME key for both casings.
- */
-export {};

package/dist/src/lsp/client-normalize.test.js

@@ -1,34 +0,0 @@
-/**
- * src/lsp/client-normalize.test.ts
- *
- * Regression guard for the Windows diagnostics-cache key mismatch: the LSP
- * client stores publishDiagnostics under normalizeUriPath(uri) (a LOWERCASE
- * drive, decoded from `file:///c%3A/…`) but retrieves under
- * normalizeFsPath(path.resolve(...)) (the cwd's UPPERCASE drive). Without
- * canonicalizing the drive letter the keys never matched, so diagnostics were
- * permanently [] on Windows — silently breaking write-time LSP feedback AND the
- * commit gate. normalizeFsPath must produce the SAME key for both casings.
- */
-import { describe, expect, it } from "vitest";
-import { normalizeFsPath } from "./client.js";
-describe("normalizeFsPath", () => {
-    it("converts backslashes to forward slashes", () => {
-        expect(normalizeFsPath("C:\\Users\\x\\bug.ts")).toBe("c:/Users/x/bug.ts");
-    });
-    it("lowercases the Windows drive letter so store/retrieve keys converge", () => {
-        // The whole point: an UPPERCASE-drive query path and a LOWERCASE-drive
-        // publishDiagnostics URI path must normalize to the identical cache key.
-        expect(normalizeFsPath("C:/Users/x/bug.ts")).toBe(normalizeFsPath("c:/Users/x/bug.ts"));
-        expect(normalizeFsPath("C:/Users/x/bug.ts")).toBe("c:/Users/x/bug.ts");
-        expect(normalizeFsPath("D:\\proj\\a.ts")).toBe("d:/proj/a.ts");
-    });
-    it("leaves POSIX absolute paths untouched (no drive letter)", () => {
-        expect(normalizeFsPath("/home/u/bug.ts")).toBe("/home/u/bug.ts");
-    });
-    it("does not mangle a non-drive leading segment", () => {
-        // Only a single leading letter + ":/" is a drive; a path segment that
-        // merely starts with a letter must be preserved.
-        expect(normalizeFsPath("src/lsp/client.ts")).toBe("src/lsp/client.ts");
-    });
-});
-//# sourceMappingURL=client-normalize.test.js.map

package/dist/src/lsp/manager.test.d.ts

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