auq-mcp-server 2.2.2 → 2.4.0

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);
+        });
+    });
+});