auq-mcp-server 2.3.0 → 2.5.0

package/dist/src/__tests__/server.abort.test.js

@@ -0,0 +1,214 @@
+/**
+ * Tests for AbortSignal and disconnect handling in SessionManager
+ */
+import { promises as fs } from "fs";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { SessionManager } from "../session/index.js";
+const testQuestions = [
+    {
+        options: [
+            { description: "Dynamic language", label: "JavaScript" },
+            { description: "Static typing", label: "TypeScript" },
+        ],
+        prompt: "Which programming language do you prefer?",
+        title: "Language",
+    },
+];
+describe("AbortSignal and Disconnect Handling", () => {
+    let sessionManager;
+    const testBaseDir = "/tmp/auq-test-abort";
+    beforeEach(async () => {
+        await fs.rm(testBaseDir, { force: true, recursive: true }).catch(() => { });
+        sessionManager = new SessionManager({
+            baseDir: testBaseDir,
+            maxSessions: 10,
+            sessionTimeout: 5000,
+        });
+        await sessionManager.initialize();
+    });
+    afterEach(async () => {
+        await fs.rm(testBaseDir, { force: true, recursive: true }).catch(() => { });
+    });
+    describe("waitForAnswers with AbortSignal", () => {
+        it("should throw ABORTED when signal fires during polling", async () => {
+            const sessionId = await sessionManager.createSession(testQuestions);
+            const controller = new AbortController();
+            // Abort after a short delay
+            setTimeout(() => controller.abort(), 100);
+            await expect(sessionManager.waitForAnswers(sessionId, 0, undefined, controller.signal)).rejects.toThrow("ABORTED");
+        });
+        it("should throw ABORTED immediately when signal is already aborted", async () => {
+            const sessionId = await sessionManager.createSession(testQuestions);
+            const controller = new AbortController();
+            controller.abort(); // Pre-abort
+            await expect(sessionManager.waitForAnswers(sessionId, 0, undefined, controller.signal)).rejects.toThrow("ABORTED");
+        });
+        it("should work normally when signal is never aborted", async () => {
+            const sessionId = await sessionManager.createSession(testQuestions);
+            const controller = new AbortController();
+            // Write answers after a short delay
+            setTimeout(async () => {
+                await sessionManager.saveSessionAnswers(sessionId, {
+                    answers: [{ questionIndex: 0, selectedOption: "JavaScript", timestamp: new Date().toISOString() }],
+                    timestamp: new Date().toISOString(),
+                    sessionId,
+                });
+            }, 100);
+            const result = await sessionManager.waitForAnswers(sessionId, 5000, undefined, controller.signal);
+            expect(result).toBe(sessionId);
+        });
+    });
+    describe("startSession with AbortSignal", () => {
+        it("should throw ABORTED when pre-aborted signal is passed", async () => {
+            const controller = new AbortController();
+            controller.abort(); // Pre-abort
+            await expect(sessionManager.startSession(testQuestions, "test-call", undefined, controller.signal)).rejects.toThrow("ABORTED");
+        });
+        it("should mark session as abandoned when pre-aborted signal is passed", async () => {
+            const controller = new AbortController();
+            controller.abort(); // Pre-abort
+            try {
+                await sessionManager.startSession(testQuestions, "test-call", undefined, controller.signal);
+            }
+            catch {
+                // Expected error
+            }
+            // Get session IDs and check the last one's status
+            const sessionIds = await sessionManager.getAllSessionIds();
+            expect(sessionIds.length).toBeGreaterThan(0);
+            const lastSessionId = sessionIds[sessionIds.length - 1];
+            const status = await sessionManager.getSessionStatus(lastSessionId);
+            expect(status?.status).toBe("abandoned");
+        });
+        it("should mark session as abandoned when signal aborts during wait", async () => {
+            const controller = new AbortController();
+            // Abort after session is created but before answers arrive
+            setTimeout(() => controller.abort(), 200);
+            await expect(sessionManager.startSession(testQuestions, "test-call", undefined, controller.signal)).rejects.toThrow("ABORTED");
+            // Verify session was marked abandoned
+            const sessionIds = await sessionManager.getAllSessionIds();
+            expect(sessionIds.length).toBeGreaterThan(0);
+            const lastSessionId = sessionIds[sessionIds.length - 1];
+            // Give abort handler time to update status
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            const status = await sessionManager.getSessionStatus(lastSessionId);
+            expect(status?.status).toBe("abandoned");
+        });
+        it("should clean up abort handler after successful completion", async () => {
+            const controller = new AbortController();
+            const signal = controller.signal;
+            // Create a session and immediately provide answers
+            const sessionPromise = sessionManager.startSession(testQuestions, "test-call", undefined, signal);
+            // Write answers quickly
+            // First we need to get the session ID, but startSession creates it internally
+            // We'll poll for any pending session
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            const sessionIds = await sessionManager.getAllSessionIds();
+            if (sessionIds.length > 0) {
+                const lastSessionId = sessionIds[sessionIds.length - 1];
+                await sessionManager.saveSessionAnswers(lastSessionId, {
+                    answers: [{ questionIndex: 0, selectedOption: "JavaScript", timestamp: new Date().toISOString() }],
+                    timestamp: new Date().toISOString(),
+                    sessionId: lastSessionId,
+                });
+            }
+            const result = await sessionPromise;
+            expect(result.formattedResponse).toBeDefined();
+            expect(result.sessionId).toBeDefined();
+            // After successful completion, aborting should have no effect
+            // (handler was cleaned up)
+            controller.abort();
+            // Session should still be completed, not abandoned
+            const status = await sessionManager.getSessionStatus(result.sessionId);
+            expect(status?.status).toBe("completed");
+        });
+    });
+    describe("createAskUserQuestionsCore with abort support", () => {
+        it("should expose markAbandoned method", async () => {
+            const { createAskUserQuestionsCore } = await import("../core/ask-user-questions.js");
+            const core = createAskUserQuestionsCore({
+                baseDir: testBaseDir,
+                sessionManager,
+            });
+            expect(core.markAbandoned).toBeDefined();
+            expect(typeof core.markAbandoned).toBe("function");
+        });
+        it("should mark session as abandoned via markAbandoned", async () => {
+            const { createAskUserQuestionsCore } = await import("../core/ask-user-questions.js");
+            const core = createAskUserQuestionsCore({
+                baseDir: testBaseDir,
+                sessionManager,
+            });
+            const sessionId = await sessionManager.createSession(testQuestions);
+            await core.markAbandoned(sessionId);
+            const status = await sessionManager.getSessionStatus(sessionId);
+            expect(status?.status).toBe("abandoned");
+        });
+        it("should pass signal through ask to startSession", async () => {
+            const { createAskUserQuestionsCore } = await import("../core/ask-user-questions.js");
+            const core = createAskUserQuestionsCore({
+                baseDir: testBaseDir,
+                sessionManager,
+            });
+            await core.ensureInitialized();
+            const controller = new AbortController();
+            controller.abort(); // Pre-abort
+            await expect(core.ask([
+                {
+                    options: [
+                        { description: "Dynamic language", label: "JavaScript" },
+                        { description: "Static typing", label: "TypeScript" },
+                    ],
+                    prompt: "Which programming language do you prefer?",
+                    title: "Language",
+                    multiSelect: false,
+                },
+            ], "test-call", undefined, controller.signal)).rejects.toThrow("ABORTED");
+        });
+    });
+    describe("activeRequests tracking (server integration)", () => {
+        it("should track and clean up active requests via Map", () => {
+            // Unit test for the activeRequests Map pattern used in server.ts
+            const activeRequests = new Map();
+            const controller = new AbortController();
+            const callId = "test-call-id";
+            // Track request
+            activeRequests.set(callId, { controller });
+            expect(activeRequests.size).toBe(1);
+            // Update with sessionId
+            const entry = activeRequests.get(callId);
+            expect(entry).toBeDefined();
+            entry.sessionId = "test-session-id";
+            // Verify update
+            expect(activeRequests.get(callId)?.sessionId).toBe("test-session-id");
+            // Simulate disconnect - abort and clean up
+            for (const [id, e] of activeRequests.entries()) {
+                e.controller.abort();
+                activeRequests.delete(id);
+            }
+            expect(activeRequests.size).toBe(0);
+            expect(controller.signal.aborted).toBe(true);
+        });
+        it("should handle multiple concurrent requests on disconnect", () => {
+            const activeRequests = new Map();
+            // Track multiple requests
+            const controllers = [];
+            for (let i = 0; i < 3; i++) {
+                const controller = new AbortController();
+                controllers.push(controller);
+                activeRequests.set(`call-${i}`, {
+                    controller,
+                    sessionId: `session-${i}`,
+                });
+            }
+            expect(activeRequests.size).toBe(3);
+            // Simulate disconnect
+            for (const [callId, entry] of activeRequests.entries()) {
+                entry.controller.abort();
+                activeRequests.delete(callId);
+            }
+            expect(activeRequests.size).toBe(0);
+            controllers.forEach((c) => expect(c.signal.aborted).toBe(true));
+        });
+    });
+});

package/dist/src/cli/commands/__tests__/answer.test.js

@@ -0,0 +1,199 @@
+/**
+ * Integration tests for the `auq answer` CLI command.
+ */
+import { promises as fs } from "fs";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { SessionManager } from "../../../session/SessionManager.js";
+import { runAnswerCommand } from "../answer.js";
+// ── Helpers ────────────────────────────────────────────────────────────────
+const testBaseDir = "/tmp/auq-test-cli-answer";
+const sampleQuestions = [
+    {
+        title: "Language",
+        prompt: "Which language do you prefer?",
+        options: [
+            { label: "TypeScript", description: "Typed JS" },
+            { label: "Python", description: "Scripting" },
+        ],
+    },
+    {
+        title: "Framework",
+        prompt: "Pick a framework",
+        options: [
+            { label: "React" },
+            { label: "Vue" },
+        ],
+    },
+];
+// Stub getSessionDirectory so the answer command always targets our temp dir.
+vi.mock("../../../session/utils.js", async (importOriginal) => {
+    const actual = (await importOriginal());
+    return {
+        ...actual,
+        getSessionDirectory: () => testBaseDir,
+    };
+});
+// ── Test Suite ─────────────────────────────────────────────────────────────
+describe("answer command", () => {
+    let sessionManager;
+    let consoleLogSpy;
+    let consoleErrorSpy;
+    let consoleWarnSpy;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let exitSpy;
+    beforeEach(async () => {
+        await fs.rm(testBaseDir, { force: true, recursive: true }).catch(() => { });
+        sessionManager = new SessionManager({
+            baseDir: testBaseDir,
+            maxSessions: 10,
+            sessionTimeout: 0,
+        });
+        await sessionManager.initialize();
+        consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+        consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
+        exitSpy = vi.spyOn(process, "exit").mockImplementation((() => { throw new Error("process.exit"); }));
+    });
+    afterEach(async () => {
+        consoleLogSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+        consoleWarnSpy.mockRestore();
+        exitSpy.mockRestore();
+        await fs.rm(testBaseDir, { force: true, recursive: true }).catch(() => { });
+    });
+    // ── Success: answer a pending session ─────────────────────────────────
+    it("should answer a pending session with valid answers JSON", async () => {
+        const sessionId = await sessionManager.createSession(sampleQuestions);
+        const answersJson = JSON.stringify({
+            "0": { selectedOption: "TypeScript" },
+            "1": { selectedOption: "React" },
+        });
+        await runAnswerCommand([sessionId, "--answers", answersJson]);
+        // Verify status is completed
+        const status = await sessionManager.getSessionStatus(sessionId);
+        expect(status?.status).toBe("completed");
+        // Verify answers were saved
+        const savedAnswers = await sessionManager.getSessionAnswers(sessionId);
+        expect(savedAnswers).not.toBeNull();
+        expect(savedAnswers.answers).toHaveLength(2);
+        expect(savedAnswers.answers[0].selectedOption).toBe("TypeScript");
+        expect(savedAnswers.answers[1].selectedOption).toBe("React");
+    });
+    it("should write answers.json to session directory", async () => {
+        const sessionId = await sessionManager.createSession(sampleQuestions);
+        const answersJson = JSON.stringify({
+            "0": { selectedOption: "Python" },
+        });
+        await runAnswerCommand([sessionId, "--answers", answersJson]);
+        // Directly verify the file exists
+        const answersPath = `${testBaseDir}/${sessionId}/answers.json`;
+        const stat = await fs.stat(answersPath);
+        expect(stat.isFile()).toBe(true);
+    });
+    // ── Reject path ──────────────────────────────────────────────────────
+    it("should reject session with reason", async () => {
+        const sessionId = await sessionManager.createSession(sampleQuestions);
+        await runAnswerCommand([
+            sessionId,
+            "--reject",
+            "--reason",
+            "not applicable",
+        ]);
+        const status = await sessionManager.getSessionStatus(sessionId);
+        expect(status?.status).toBe("rejected");
+        expect(status?.rejectionReason).toBe("not applicable");
+    });
+    it("should reject session without reason", async () => {
+        const sessionId = await sessionManager.createSession(sampleQuestions);
+        await runAnswerCommand([sessionId, "--reject"]);
+        const status = await sessionManager.getSessionStatus(sessionId);
+        expect(status?.status).toBe("rejected");
+    });
+    // ── Error cases ──────────────────────────────────────────────────────
+    it("should error when sessionId is missing", async () => {
+        await expect(runAnswerCommand([])).rejects.toThrow("process.exit");
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        const errorOutput = consoleErrorSpy.mock.calls.map((c) => c[0]).join("\n");
+        expect(errorOutput).toContain("Missing session ID");
+    });
+    it("should error when session does not exist", async () => {
+        const fakeId = "00000000-0000-4000-a000-000000000000";
+        await expect(runAnswerCommand([fakeId, "--answers", '{ "0": {} }'])).rejects.toThrow("process.exit");
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        const errorOutput = consoleErrorSpy.mock.calls.map((c) => c[0]).join("\n");
+        expect(errorOutput).toContain("Session not found");
+    });
+    it("should error when answers JSON is malformed", async () => {
+        const sessionId = await sessionManager.createSession(sampleQuestions);
+        await expect(runAnswerCommand([sessionId, "--answers", "not-json"])).rejects.toThrow("process.exit");
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        const errorOutput = consoleErrorSpy.mock.calls.map((c) => c[0]).join("\n");
+        expect(errorOutput).toContain("Invalid answers JSON");
+    });
+    it("should error when neither --answers nor --reject is provided", async () => {
+        const sessionId = await sessionManager.createSession(sampleQuestions);
+        await expect(runAnswerCommand([sessionId])).rejects.toThrow("process.exit");
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        const errorOutput = consoleErrorSpy.mock.calls.map((c) => c[0]).join("\n");
+        expect(errorOutput).toContain("Either --answers or --reject is required");
+    });
+    // ── Abandoned session handling ────────────────────────────────────────
+    it("should warn for abandoned session without --force", async () => {
+        const sessionId = await sessionManager.createSession(sampleQuestions);
+        // Mark as abandoned
+        await sessionManager.updateSessionStatus(sessionId, "abandoned");
+        await expect(runAnswerCommand([
+            sessionId,
+            "--answers",
+            JSON.stringify({ "0": { selectedOption: "TypeScript" } }),
+        ])).rejects.toThrow("process.exit");
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        const errorOutput = consoleErrorSpy.mock.calls.map((c) => c[0]).join("\n");
+        expect(errorOutput).toContain("AI disconnected");
+        expect(errorOutput).toContain("--force");
+    });
+    it("should succeed for abandoned session with --force", async () => {
+        const sessionId = await sessionManager.createSession(sampleQuestions);
+        await sessionManager.updateSessionStatus(sessionId, "abandoned");
+        const answersJson = JSON.stringify({
+            "0": { selectedOption: "TypeScript" },
+            "1": { selectedOption: "React" },
+        });
+        await runAnswerCommand([sessionId, "--answers", answersJson, "--force"]);
+        const status = await sessionManager.getSessionStatus(sessionId);
+        expect(status?.status).toBe("completed");
+        // Check the warning was emitted
+        const warnOutput = consoleWarnSpy.mock.calls.map((c) => c[0]).join("\n");
+        expect(warnOutput).toContain("Warning");
+    });
+    // ── JSON output ──────────────────────────────────────────────────────
+    it("should produce valid JSON output with --json flag on answer", async () => {
+        const sessionId = await sessionManager.createSession(sampleQuestions);
+        const answersJson = JSON.stringify({
+            "0": { selectedOption: "TypeScript" },
+        });
+        await runAnswerCommand([sessionId, "--answers", answersJson, "--json"]);
+        // console.log should have been called with valid JSON
+        const jsonOutput = consoleLogSpy.mock.calls[0][0];
+        const result = JSON.parse(jsonOutput);
+        expect(result.success).toBe(true);
+        expect(result.sessionId).toBe(sessionId);
+        expect(result.status).toBe("completed");
+    });
+    it("should produce valid JSON output with --json flag on reject", async () => {
+        const sessionId = await sessionManager.createSession(sampleQuestions);
+        await runAnswerCommand([sessionId, "--reject", "--json"]);
+        const jsonOutput = consoleLogSpy.mock.calls[0][0];
+        const result = JSON.parse(jsonOutput);
+        expect(result.success).toBe(true);
+        expect(result.sessionId).toBe(sessionId);
+        expect(result.status).toBe("rejected");
+    });
+    it("should produce valid JSON error output with --json flag", async () => {
+        await expect(runAnswerCommand(["--json"])).rejects.toThrow("process.exit");
+        const jsonOutput = consoleLogSpy.mock.calls[0][0];
+        const result = JSON.parse(jsonOutput);
+        expect(result.success).toBe(false);
+        expect(result.error).toBeDefined();
+    });
+});

package/dist/src/cli/commands/__tests__/config.test.js

@@ -0,0 +1,218 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import * as fs from "fs";
+import { runConfigCommand } from "../config.js";
+import { DEFAULT_CONFIG } from "../../../config/defaults.js";
+// Mock fs module
+vi.mock("fs", () => ({
+    existsSync: vi.fn(),
+    readFileSync: vi.fn(),
+    writeFileSync: vi.fn(),
+    mkdirSync: vi.fn(),
+}));
+vi.mock("os", () => ({
+    homedir: vi.fn(() => "/home/testuser"),
+}));
+describe("config command", () => {
+    let consoleLogSpy;
+    let consoleErrorSpy;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        process.exitCode = undefined;
+        delete process.env.XDG_CONFIG_HOME;
+        consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+        consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        // Default: no config files exist
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+    });
+    afterEach(() => {
+        consoleLogSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+        vi.restoreAllMocks();
+        process.exitCode = undefined;
+    });
+    // ── Config Get ──────────────────────────────────────────────────
+    describe("config get", () => {
+        it("should show all config values with defaults when no config files exist", async () => {
+            await runConfigCommand(["get"]);
+            // Should print key=value lines for all known keys
+            expect(consoleLogSpy).toHaveBeenCalled();
+            const allOutput = consoleLogSpy.mock.calls.map((c) => c[0]).join("\n");
+            expect(allOutput).toContain("maxOptions = 5");
+            expect(allOutput).toContain("sessionTimeout = 0");
+            expect(allOutput).toContain("staleThreshold = 7200000");
+            expect(allOutput).toContain("notifyOnStale = true");
+            expect(allOutput).toContain("staleAction = warn");
+            expect(allOutput).toContain("notifications.enabled = true");
+            expect(allOutput).toContain("notifications.sound = true");
+        });
+        it("should show specific key value", async () => {
+            await runConfigCommand(["get", "maxOptions"]);
+            expect(consoleLogSpy).toHaveBeenCalledWith("maxOptions = 5");
+        });
+        it("should show nested key value with dot notation", async () => {
+            await runConfigCommand(["get", "notifications.enabled"]);
+            expect(consoleLogSpy).toHaveBeenCalledWith("notifications.enabled = true");
+        });
+        it("should error on unknown key", async () => {
+            await runConfigCommand(["get", "unknownKey"]);
+            expect(process.exitCode).toBe(1);
+            expect(consoleErrorSpy).toHaveBeenCalled();
+            const errorOutput = consoleErrorSpy.mock.calls.map((c) => c[0]).join("\n");
+            expect(errorOutput).toContain("Unknown config key");
+            expect(errorOutput).toContain("unknownKey");
+        });
+        it("should output valid JSON with --json flag for all config", async () => {
+            await runConfigCommand(["get", "--json"]);
+            expect(consoleLogSpy).toHaveBeenCalledTimes(1);
+            const output = consoleLogSpy.mock.calls[0][0];
+            const parsed = JSON.parse(output);
+            expect(parsed.success).toBe(true);
+            expect(parsed.config).toBeDefined();
+            expect(parsed.config.maxOptions).toBe(DEFAULT_CONFIG.maxOptions);
+        });
+        it("should output valid JSON with --json flag for specific key", async () => {
+            await runConfigCommand(["get", "staleThreshold", "--json"]);
+            const output = consoleLogSpy.mock.calls[0][0];
+            const parsed = JSON.parse(output);
+            expect(parsed.success).toBe(true);
+            expect(parsed.key).toBe("staleThreshold");
+            expect(parsed.value).toBe(7200000);
+        });
+        it("should merge local config over defaults", async () => {
+            const cwd = process.cwd();
+            const localPath = `${cwd}/.auqrc.json`;
+            vi.mocked(fs.existsSync).mockImplementation((path) => {
+                return String(path) === localPath;
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ maxOptions: 8 }));
+            await runConfigCommand(["get", "maxOptions"]);
+            expect(consoleLogSpy).toHaveBeenCalledWith("maxOptions = 8");
+        });
+    });
+    // ── Config Set ──────────────────────────────────────────────────
+    describe("config set", () => {
+        it("should write valid key to local config file", async () => {
+            const cwd = process.cwd();
+            const expectedPath = `${cwd}/.auqrc.json`;
+            // Simulate directory exists but file does not
+            vi.mocked(fs.existsSync).mockImplementation((path) => {
+                return String(path) === cwd;
+            });
+            await runConfigCommand(["set", "staleThreshold", "3600000"]);
+            expect(process.exitCode).toBeUndefined();
+            expect(fs.writeFileSync).toHaveBeenCalled();
+            const writeCall = vi.mocked(fs.writeFileSync).mock.calls[0];
+            expect(String(writeCall[0])).toBe(expectedPath);
+            const written = JSON.parse(writeCall[1]);
+            expect(written.staleThreshold).toBe(3600000);
+        });
+        it("should write to global config with --global flag", async () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            await runConfigCommand(["set", "staleThreshold", "3600000", "--global"]);
+            expect(process.exitCode).toBeUndefined();
+            expect(fs.writeFileSync).toHaveBeenCalled();
+            const writeCall = vi.mocked(fs.writeFileSync).mock.calls[0];
+            expect(String(writeCall[0])).toContain(".config/auq/.auqrc.json");
+        });
+        it("should create directory if it doesn't exist", async () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            await runConfigCommand(["set", "maxOptions", "8", "--global"]);
+            expect(fs.mkdirSync).toHaveBeenCalledWith(expect.stringContaining(".config/auq"), { recursive: true });
+        });
+        it("should merge with existing config", async () => {
+            const cwd = process.cwd();
+            const localPath = `${cwd}/.auqrc.json`;
+            vi.mocked(fs.existsSync).mockImplementation((path) => {
+                return String(path) === localPath || String(path) === cwd;
+            });
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ maxOptions: 6 }));
+            await runConfigCommand(["set", "staleThreshold", "5000000"]);
+            expect(fs.writeFileSync).toHaveBeenCalled();
+            const writeCall = vi.mocked(fs.writeFileSync).mock.calls[0];
+            const written = JSON.parse(writeCall[1]);
+            // Existing key should be preserved
+            expect(written.maxOptions).toBe(6);
+            // New key should be added
+            expect(written.staleThreshold).toBe(5000000);
+        });
+        it("should error on unknown config key with valid keys list", async () => {
+            await runConfigCommand(["set", "badKey", "value"]);
+            expect(process.exitCode).toBe(1);
+            expect(consoleErrorSpy).toHaveBeenCalled();
+            const errorOutput = consoleErrorSpy.mock.calls.map((c) => c[0]).join("\n");
+            expect(errorOutput).toContain("Unknown config key");
+            expect(errorOutput).toContain("badKey");
+            // Should list valid keys
+            expect(errorOutput).toContain("maxOptions");
+            expect(errorOutput).toContain("staleThreshold");
+        });
+        it("should error on invalid value type", async () => {
+            await runConfigCommand(["set", "maxOptions", "notanumber"]);
+            expect(process.exitCode).toBe(1);
+            expect(consoleErrorSpy).toHaveBeenCalled();
+            const errorOutput = consoleErrorSpy.mock.calls.map((c) => c[0]).join("\n");
+            expect(errorOutput).toContain("Invalid value");
+        });
+        it("should coerce boolean string values correctly", async () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            await runConfigCommand(["set", "notifyOnStale", "false"]);
+            expect(process.exitCode).toBeUndefined();
+            expect(fs.writeFileSync).toHaveBeenCalled();
+            const writeCall = vi.mocked(fs.writeFileSync).mock.calls[0];
+            const written = JSON.parse(writeCall[1]);
+            expect(written.notifyOnStale).toBe(false);
+        });
+        it("should validate enum values", async () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            await runConfigCommand(["set", "staleAction", "archive"]);
+            expect(process.exitCode).toBeUndefined();
+            expect(fs.writeFileSync).toHaveBeenCalled();
+            const writeCall = vi.mocked(fs.writeFileSync).mock.calls[0];
+            const written = JSON.parse(writeCall[1]);
+            expect(written.staleAction).toBe("archive");
+        });
+        it("should reject invalid enum values", async () => {
+            await runConfigCommand(["set", "staleAction", "invalid_action"]);
+            expect(process.exitCode).toBe(1);
+            expect(consoleErrorSpy).toHaveBeenCalled();
+        });
+        it("should handle nested key set with dot notation", async () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            await runConfigCommand(["set", "notifications.enabled", "false"]);
+            expect(process.exitCode).toBeUndefined();
+            expect(fs.writeFileSync).toHaveBeenCalled();
+            const writeCall = vi.mocked(fs.writeFileSync).mock.calls[0];
+            const written = JSON.parse(writeCall[1]);
+            expect(written.notifications.enabled).toBe(false);
+        });
+        it("should output JSON with --json flag", async () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            await runConfigCommand(["set", "staleThreshold", "3600000", "--json"]);
+            expect(consoleLogSpy).toHaveBeenCalledTimes(1);
+            const output = consoleLogSpy.mock.calls[0][0];
+            const parsed = JSON.parse(output);
+            expect(parsed.success).toBe(true);
+            expect(parsed.key).toBe("staleThreshold");
+            expect(parsed.value).toBe(3600000);
+            expect(parsed.file).toBeDefined();
+        });
+        it("should error when key and value are missing", async () => {
+            await runConfigCommand(["set"]);
+            expect(process.exitCode).toBe(1);
+            expect(consoleErrorSpy).toHaveBeenCalled();
+        });
+    });
+    // ── Config help ─────────────────────────────────────────────────
+    describe("config help", () => {
+        it("should show usage help when no subcommand provided", async () => {
+            await runConfigCommand([]);
+            expect(consoleLogSpy).toHaveBeenCalled();
+            const output = consoleLogSpy.mock.calls.map((c) => c[0]).join("\n");
+            expect(output).toContain("Usage");
+        });
+        it("should show usage and set exitCode for unknown subcommand", async () => {
+            await runConfigCommand(["unknown"]);
+            expect(process.exitCode).toBe(1);
+        });
+    });
+});