auq-mcp-server 2.6.3 → 2.7.0

package/dist/src/cli/commands/fetch-answers.js

@@ -0,0 +1,205 @@
+/**
+ * CLI Fetch-Answers Command — `auq fetch-answers [<session-id>] [--blocking] [--json] [--unread]`
+ * Retrieves answers for a session asynchronously, or lists unread sessions.
+ */
+import { SessionManager } from "../../session/SessionManager.js";
+import { ResponseFormatter } from "../../session/ResponseFormatter.js";
+import { getSessionDirectory } from "../../session/utils.js";
+import { formatAge, outputResult, parseFlags } from "../utils.js";
+/**
+ * Run the `auq fetch-answers` command.
+ *
+ * Usage:
+ *   auq fetch-answers                        # list all unread sessions (default)
+ *   auq fetch-answers --unread               # same as above
+ *   auq fetch-answers <sessionId>            # fetch answers for specific session
+ *   auq fetch-answers <sessionId> --blocking # wait until answered, then fetch
+ *   auq fetch-answers <sessionId> --json     # output as JSON
+ */
+export async function runFetchAnswersCommand(args) {
+    const { flags, positionals } = parseFlags(args);
+    const jsonMode = flags.json === true;
+    const blockingMode = flags.blocking === true;
+    const unreadMode = flags.unread === true;
+    const sessionIdArg = positionals[0];
+    // ── Initialise SessionManager ─────────────────────────────────────
+    const sessionManager = new SessionManager({
+        baseDir: getSessionDirectory(),
+    });
+    await sessionManager.initialize();
+    // ── Mode B: List unread sessions ──────────────────────────────────
+    // Default (no session-id) OR explicit --unread flag
+    if (!sessionIdArg || unreadMode) {
+        // Guard: if --blocking was passed without a session ID, that's an error
+        if (blockingMode && !sessionIdArg) {
+            outputResult({ success: false, error: "--blocking requires a session ID.\n\nUsage:\n  auq fetch-answers <session-id> [--blocking] [--json]\n  auq fetch-answers --unread [--json]" }, jsonMode);
+            process.exitCode = 1;
+            return;
+        }
+        return listUnreadSessions(sessionManager, jsonMode);
+    }
+    // ── Mode A: Fetch specific session ────────────────────────────────
+    return fetchSession(sessionManager, sessionIdArg, blockingMode, jsonMode);
+}
+// ── List Unread Sessions ──────────────────────────────────────────────
+async function listUnreadSessions(sessionManager, jsonMode) {
+    const unreadIds = await sessionManager.getUnreadSessions();
+    if (jsonMode) {
+        const entries = await Promise.all(unreadIds.map(async (sessionId) => {
+            const status = await sessionManager.getSessionStatus(sessionId);
+            const request = await sessionManager.getSessionRequest(sessionId);
+            return {
+                sessionId,
+                status: status?.status ?? "unknown",
+                createdAt: status?.createdAt ?? null,
+                lastReadAt: null,
+                questionCount: request?.questions?.length ?? status?.totalQuestions ?? 0,
+            };
+        }));
+        console.log(JSON.stringify(entries, null, 2));
+        return;
+    }
+    if (unreadIds.length === 0) {
+        console.log("No unread sessions.");
+        return;
+    }
+    console.log("Unread sessions:");
+    console.log("");
+    // Build table rows
+    const rows = [];
+    for (const sessionId of unreadIds) {
+        const status = await sessionManager.getSessionStatus(sessionId);
+        const request = await sessionManager.getSessionRequest(sessionId);
+        rows.push({
+            id: sessionId.slice(0, 8),
+            status: status?.status ?? "unknown",
+            age: status ? formatAge(status.createdAt) : "?",
+            questions: request?.questions?.length ?? status?.totalQuestions ?? 0,
+        });
+    }
+    // Print header
+    console.log("ID        Status     Age     Questions");
+    for (const row of rows) {
+        const id = row.id.padEnd(10);
+        const status = row.status.padEnd(11);
+        const age = row.age.padEnd(8);
+        console.log(`${id}${status}${age}${row.questions}`);
+    }
+}
+// ── Fetch Specific Session ────────────────────────────────────────────
+async function fetchSession(sessionManager, sessionIdArg, blockingMode, jsonMode) {
+    // ── Resolve session ID (full UUID or 8-char short prefix) ─────────
+    let sessionId;
+    if (sessionIdArg.length === 8) {
+        // Try prefix resolution
+        const allIds = await sessionManager.getAllSessionIds();
+        const match = allIds.find((id) => id.startsWith(sessionIdArg));
+        if (!match) {
+            outputResult({ success: false, error: `Session not found: ${sessionIdArg}` }, jsonMode);
+            process.exitCode = 1;
+            return;
+        }
+        sessionId = match;
+    }
+    else {
+        // Treat as full UUID
+        const exists = await sessionManager.sessionExists(sessionIdArg);
+        if (!exists) {
+            outputResult({ success: false, error: `Session not found: ${sessionIdArg}` }, jsonMode);
+            process.exitCode = 1;
+            return;
+        }
+        sessionId = sessionIdArg;
+    }
+    // ── Get current status ────────────────────────────────────────────
+    let status = await sessionManager.getSessionStatus(sessionId);
+    if (!status) {
+        outputResult({ success: false, error: `Could not read session data for: ${sessionId}` }, jsonMode);
+        process.exitCode = 1;
+        return;
+    }
+    // ── Handle blocking wait for pending/in-progress sessions ─────────
+    const isPending = status.status === "pending" || status.status === "in-progress";
+    if (isPending && blockingMode) {
+        try {
+            await sessionManager.waitForAnswers(sessionId);
+            // Re-read status after wait
+            status = await sessionManager.getSessionStatus(sessionId);
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            if (errMsg === "SESSION_REJECTED") {
+                // Will be handled below after re-reading status
+                status = await sessionManager.getSessionStatus(sessionId);
+            }
+            else {
+                outputResult({ success: false, error: `Error waiting for answers: ${errMsg}` }, jsonMode);
+                process.exitCode = 1;
+                return;
+            }
+        }
+    }
+    // Re-check status after potential wait
+    const currentStatus = status?.status ?? "unknown";
+    // ── Handle completed session ──────────────────────────────────────
+    if (currentStatus === "completed") {
+        const request = await sessionManager.getSessionRequest(sessionId);
+        let answersData = null;
+        try {
+            answersData = await sessionManager.getSessionAnswers(sessionId);
+        }
+        catch {
+            // answers.json may not exist yet, treat as pending
+        }
+        if (!answersData || !request) {
+            outputResult({ success: false, error: `Could not read answers for: ${sessionId}` }, jsonMode);
+            process.exitCode = 1;
+            return;
+        }
+        // Mark as read
+        await sessionManager.markSessionAsRead(sessionId);
+        const lastReadAt = new Date().toISOString();
+        if (jsonMode) {
+            console.log(JSON.stringify({
+                sessionId,
+                status: "completed",
+                answers: answersData.answers,
+                lastReadAt,
+            }, null, 2));
+            return;
+        }
+        const formatted = ResponseFormatter.formatUserResponse(answersData, request.questions, sessionId);
+        console.log(formatted);
+        return;
+    }
+    // ── Handle pending/in-progress (non-blocking) ─────────────────────
+    if (currentStatus === "pending" || currentStatus === "in-progress") {
+        if (jsonMode) {
+            console.log(JSON.stringify({ sessionId, status: currentStatus, answers: null, lastReadAt: null }, null, 2));
+            return;
+        }
+        console.log(ResponseFormatter.formatPendingStatus(sessionId));
+        return;
+    }
+    // ── Handle rejected session ───────────────────────────────────────
+    if (currentStatus === "rejected") {
+        if (jsonMode) {
+            console.log(JSON.stringify({
+                sessionId,
+                status: "rejected",
+                answers: null,
+                lastReadAt: null,
+                rejectionReason: status?.rejectionReason ?? null,
+            }, null, 2));
+            return;
+        }
+        console.log(ResponseFormatter.formatRejectedStatus(sessionId, status?.rejectionReason));
+        return;
+    }
+    // ── Handle abandoned / timed_out ──────────────────────────────────
+    if (jsonMode) {
+        console.log(JSON.stringify({ sessionId, status: currentStatus, answers: null, lastReadAt: null }, null, 2));
+        return;
+    }
+    console.log(ResponseFormatter.formatSessionStatus(sessionId, currentStatus));
+}

package/dist/src/cli/commands/history.js

@@ -0,0 +1,375 @@
+/**
+ * CLI History Command — `auq history` and `auq history show <id>`
+ * List and browse historical sessions with filtering and search.
+ */
+import chalk from "chalk";
+import { SessionManager } from "../../session/SessionManager.js";
+import { getSessionDirectory } from "../../session/utils.js";
+import { formatAge, parseFlags } from "../utils.js";
+// ── Helper Functions ────────────────────────────────────────────────
+function getStatusIndicator(status) {
+    switch (status) {
+        case "completed":
+            return chalk.green("✓ completed");
+        case "rejected":
+            return chalk.red("✗ rejected");
+        case "pending":
+            return chalk.yellow("⏳ pending");
+        case "in-progress":
+            return chalk.yellow("⏳ in-progress");
+        case "timed_out":
+            return chalk.yellow("⏱ timed_out");
+        case "abandoned":
+            return chalk.dim("… abandoned");
+        default:
+            return status;
+    }
+}
+function getReadIndicator(lastReadAt) {
+    return lastReadAt ? "✓" : "─";
+}
+function truncatePreview(text, maxLen) {
+    if (text.length <= maxLen)
+        return text;
+    return text.slice(0, maxLen - 1) + "…";
+}
+function padColumn(text, width) {
+    // Strip ANSI escape codes for length calculation
+    const plainText = text.replace(/\x1b\[[0-9;]*m/g, "");
+    const padding = Math.max(0, width - plainText.length);
+    return text + " ".repeat(padding);
+}
+async function resolveSessionId(sessionManager, idArg) {
+    // Try exact full UUID match first
+    const exists = await sessionManager.sessionExists(idArg);
+    if (exists)
+        return idArg;
+    // Try short ID prefix match
+    const allIds = await sessionManager.getAllSessionIds();
+    const shortMatches = allIds.filter((id) => id.startsWith(idArg));
+    if (shortMatches.length === 1)
+        return shortMatches[0];
+    return null;
+}
+// ── List History ────────────────────────────────────────────────────
+async function listHistory(_positionals, flags) {
+    const jsonMode = flags.json === true;
+    const showAll = flags.all === true;
+    const filterUnread = flags.unread === true;
+    const sessionFilter = typeof flags.session === "string" ? flags.session : undefined;
+    const searchFilter = typeof flags.search === "string" ? flags.search.toLowerCase() : undefined;
+    const limitRaw = typeof flags.limit === "string" ? parseInt(flags.limit, 10) : 20;
+    const limit = isNaN(limitRaw) ? 20 : Math.max(1, limitRaw);
+    // Initialize SessionManager
+    const sessionManager = new SessionManager({
+        baseDir: getSessionDirectory(),
+    });
+    await sessionManager.initialize();
+    // Get all session IDs
+    const sessionIds = await sessionManager.getAllSessionIds();
+    // Build entries
+    const entries = [];
+    let abandonedCount = 0;
+    for (const sessionId of sessionIds) {
+        let status = null;
+        let request = null;
+        let answersData = null;
+        try {
+            status = await sessionManager.getSessionStatus(sessionId);
+            if (!status)
+                continue;
+            request = await sessionManager.getSessionRequest(sessionId);
+            try {
+                answersData = await sessionManager.getSessionAnswers(sessionId);
+            }
+            catch {
+                // answers.json may not exist — that's ok
+            }
+        }
+        catch {
+            continue; // Skip broken sessions
+        }
+        if (!status)
+            continue;
+        const isAbandoned = status.status === "abandoned";
+        if (isAbandoned)
+            abandonedCount++;
+        const questionCount = request?.questions?.length ?? status.totalQuestions ?? 0;
+        const answeredCount = answersData?.answers?.length ?? 0;
+        const lastReadAt = answersData?.lastReadAt;
+        // Build preview from first question prompt
+        const firstQuestion = request?.questions?.[0];
+        const preview = firstQuestion
+            ? truncatePreview(firstQuestion.prompt, 40)
+            : "";
+        // Build search text from all question prompts and answer data
+        const searchTextParts = [];
+        if (request?.questions) {
+            for (const q of request.questions) {
+                searchTextParts.push(q.prompt.toLowerCase());
+                if (q.title)
+                    searchTextParts.push(q.title.toLowerCase());
+            }
+        }
+        if (answersData?.answers) {
+            for (const a of answersData.answers) {
+                if (a.selectedOption)
+                    searchTextParts.push(a.selectedOption.toLowerCase());
+                if (a.selectedOptions) {
+                    for (const opt of a.selectedOptions)
+                        searchTextParts.push(opt.toLowerCase());
+                }
+                if (a.customText)
+                    searchTextParts.push(a.customText.toLowerCase());
+            }
+        }
+        const searchText = searchTextParts.join(" ");
+        entries.push({
+            sessionId,
+            shortId: sessionId.slice(0, 8),
+            status: status.status,
+            createdAt: status.createdAt,
+            lastReadAt,
+            questionCount,
+            answeredCount,
+            preview,
+            searchText,
+            isAbandoned,
+        });
+    }
+    // Sort by createdAt descending (newest first)
+    entries.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    // Apply filters
+    let filtered = [...entries];
+    // Base filter: exclude abandoned unless --all
+    if (!showAll) {
+        filtered = filtered.filter((e) => !e.isAbandoned);
+    }
+    // --session filter
+    if (sessionFilter !== undefined) {
+        filtered = filtered.filter((e) => e.sessionId === sessionFilter ||
+            e.sessionId.startsWith(sessionFilter));
+        if (filtered.length === 0) {
+            if (jsonMode) {
+                console.log(JSON.stringify([], null, 2));
+            }
+            else {
+                console.error(`Session not found: ${sessionFilter}`);
+            }
+            process.exitCode = 1;
+            return;
+        }
+    }
+    // --unread filter
+    if (filterUnread) {
+        filtered = filtered.filter((e) => e.status === "completed" && !e.lastReadAt);
+    }
+    // --search filter
+    if (searchFilter !== undefined) {
+        filtered = filtered.filter((e) => e.searchText.includes(searchFilter));
+    }
+    // Apply limit
+    const displayed = filtered.slice(0, limit);
+    // JSON output
+    if (jsonMode) {
+        const result = displayed.map((e) => ({
+            sessionId: e.sessionId,
+            status: e.status,
+            createdAt: e.createdAt,
+            lastReadAt: e.lastReadAt ?? null,
+            questionCount: e.questionCount,
+            answeredCount: e.answeredCount,
+            preview: e.preview,
+        }));
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    // Empty state
+    if (displayed.length === 0) {
+        console.log("No sessions found.");
+        return;
+    }
+    // Table output
+    const headerLine = padColumn("ID", 10) +
+        padColumn("Status", 16) +
+        padColumn("Time", 10) +
+        padColumn("Read", 7) +
+        padColumn("Q", 6) +
+        "Preview";
+    console.log(chalk.dim(headerLine));
+    for (const entry of displayed) {
+        const statusStr = getStatusIndicator(entry.status);
+        const age = formatAge(entry.createdAt);
+        const readStr = getReadIndicator(entry.lastReadAt);
+        const questionsStr = `${entry.answeredCount}/${entry.questionCount}`;
+        const line = padColumn(entry.shortId, 10) +
+            padColumn(statusStr, 16) +
+            padColumn(age, 10) +
+            padColumn(readStr, 7) +
+            padColumn(questionsStr, 6) +
+            entry.preview;
+        console.log(line);
+    }
+    // Hint line when abandoned sessions are hidden
+    if (!showAll && abandonedCount > 0) {
+        console.log(chalk.dim(`\n${displayed.length} sessions shown (${abandonedCount} abandoned hidden, use --all)`));
+    }
+}
+// ── Show History ────────────────────────────────────────────────────
+async function showHistory(positionals, flags) {
+    const jsonMode = flags.json === true;
+    const idArg = positionals[0];
+    if (!idArg) {
+        console.error("Missing session ID. Usage: auq history show <sessionId> [--json]");
+        process.exitCode = 1;
+        return;
+    }
+    // Initialize SessionManager
+    const sessionManager = new SessionManager({
+        baseDir: getSessionDirectory(),
+    });
+    await sessionManager.initialize();
+    // Resolve session ID (full UUID or short prefix)
+    const sessionId = await resolveSessionId(sessionManager, idArg);
+    if (!sessionId) {
+        console.error(`Session not found: ${idArg}`);
+        process.exitCode = 1;
+        return;
+    }
+    // Load session data
+    const status = await sessionManager.getSessionStatus(sessionId);
+    const request = await sessionManager.getSessionRequest(sessionId);
+    let answersData = null;
+    try {
+        answersData = await sessionManager.getSessionAnswers(sessionId);
+    }
+    catch {
+        // answers.json may not exist for pending/abandoned sessions
+    }
+    if (!status || !request) {
+        console.error(`Could not read session data for: ${idArg}`);
+        process.exitCode = 1;
+        return;
+    }
+    const questions = request.questions;
+    const answers = answersData?.answers ?? null;
+    const lastReadAt = answersData?.lastReadAt;
+    const answeredCount = answers?.length ?? 0;
+    // Build answer lookup (questionIndex → answer)
+    const answerMap = new Map();
+    if (answers) {
+        for (const a of answers) {
+            answerMap.set(a.questionIndex, {
+                selectedOption: a.selectedOption,
+                selectedOptions: a.selectedOptions,
+                customText: a.customText,
+            });
+        }
+    }
+    // JSON output
+    if (jsonMode) {
+        const result = {
+            sessionId,
+            status: status.status,
+            createdAt: status.createdAt,
+            lastReadAt: lastReadAt ?? null,
+            questionCount: questions.length,
+            answeredCount,
+            questions: questions.map((q, i) => {
+                const answer = answerMap.get(i);
+                const selectedLabels = new Set();
+                if (answer?.selectedOption)
+                    selectedLabels.add(answer.selectedOption);
+                if (answer?.selectedOptions) {
+                    for (const opt of answer.selectedOptions)
+                        selectedLabels.add(opt);
+                }
+                return {
+                    index: i,
+                    title: q.title,
+                    prompt: q.prompt,
+                    multiSelect: q.multiSelect ?? false,
+                    options: q.options.map((o) => ({
+                        label: o.label,
+                        description: o.description ?? null,
+                        selected: selectedLabels.has(o.label),
+                    })),
+                    customText: answer?.customText ?? null,
+                };
+            }),
+        };
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    // Human-readable output
+    const age = formatAge(status.createdAt);
+    const createdAbsolute = new Date(status.createdAt)
+        .toISOString()
+        .replace("T", " ")
+        .replace(/\.\d+Z$/, "Z");
+    console.log(`Session: ${sessionId}`);
+    console.log(`Status: ${getStatusIndicator(status.status)}`);
+    console.log(`Created: ${createdAbsolute} (${age})`);
+    if (lastReadAt) {
+        const readAbsolute = new Date(lastReadAt)
+            .toISOString()
+            .replace("T", " ")
+            .replace(/\.\d+Z$/, "Z");
+        console.log(`Read: ✓ ${readAbsolute}`);
+    }
+    else {
+        console.log("Read: unread");
+    }
+    console.log(`Questions: ${answeredCount}/${questions.length} answered`);
+    console.log("");
+    // Display questions with options
+    for (let i = 0; i < questions.length; i++) {
+        const q = questions[i];
+        const answer = answerMap.get(i);
+        // Determine which option labels are selected
+        const selectedLabels = new Set();
+        if (answer?.selectedOption)
+            selectedLabels.add(answer.selectedOption);
+        if (answer?.selectedOptions) {
+            for (const opt of answer.selectedOptions)
+                selectedLabels.add(opt);
+        }
+        console.log(`${i + 1}. ${q.title}`);
+        console.log(`   ${q.prompt}`);
+        let otherOptionHandled = false;
+        for (const opt of q.options) {
+            const isSelected = selectedLabels.has(opt.label);
+            const descPart = opt.description ? ` — ${opt.description}` : "";
+            // If this is the "Other" option and there's custom text, show custom text inline
+            if (isSelected && answer?.customText && opt.label === "Other") {
+                console.log(`   (selected) Other: '${answer.customText}'`);
+                otherOptionHandled = true;
+            }
+            else if (isSelected) {
+                console.log(`   (selected) ${opt.label}${descPart}`);
+            }
+            else {
+                console.log(`   ${opt.label}${descPart}`);
+            }
+        }
+        // If customText exists but "Other" is not a listed option, show it as additional entry
+        if (answer?.customText && !otherOptionHandled) {
+            const hasOtherOption = q.options.some((o) => o.label === "Other");
+            if (!hasOtherOption) {
+                console.log(`   (selected) Other: '${answer.customText}'`);
+            }
+        }
+        console.log("");
+    }
+}
+// ── History Command Dispatcher ──────────────────────────────────────
+export async function runHistoryCommand(args) {
+    const { flags, positionals } = parseFlags(args);
+    const subcommand = positionals[0];
+    if (subcommand === "show") {
+        await showHistory(positionals.slice(1), flags);
+    }
+    else {
+        await listHistory(positionals, flags);
+    }
+}

package/dist/src/config/__tests__/ConfigLoader.test.js

@@ -132,4 +132,42 @@ describe("ConfigLoader", () => {
             expect(config.staleThreshold).toBe(DEFAULT_CONFIG.staleThreshold);
         });
     });
+    describe("renderer config options", () => {
+        it("should have 'ink' as default renderer when no config files exist", () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const config = loadConfig();
+            expect(config.renderer).toBe("ink");
+        });
+        it("should include renderer in DEFAULT_CONFIG as 'ink'", () => {
+            expect(DEFAULT_CONFIG.renderer).toBe("ink");
+        });
+        it("should load renderer: 'opentui' from config file", () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ renderer: "opentui" }));
+            const config = loadConfig();
+            expect(config.renderer).toBe("opentui");
+        });
+        it("should load renderer: 'ink' from config file", () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ renderer: "ink" }));
+            const config = loadConfig();
+            expect(config.renderer).toBe("ink");
+        });
+        it("should fall back to 'ink' for invalid renderer value", () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ renderer: "chrome" }));
+            const config = loadConfig();
+            // Invalid enum value should be ignored, default ('ink') used
+            expect(config.renderer).toBe(DEFAULT_CONFIG.renderer);
+            expect(config.renderer).toBe("ink");
+        });
+        it("should preserve other config values alongside renderer setting", () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ renderer: "opentui", theme: "dark" }));
+            const config = loadConfig();
+            expect(config.renderer).toBe("opentui");
+            expect(config.theme).toBe("dark");
+            expect(config.maxOptions).toBe(DEFAULT_CONFIG.maxOptions);
+        });
+    });
 });

package/dist/src/config/defaults.js

@@ -8,6 +8,7 @@ export const DEFAULT_CONFIG = {
     language: "auto",
     theme: "system",
     autoSelectRecommended: true,
+    renderer: "ink",
     staleThreshold: 7200000, // 2 hours in ms
     notifyOnStale: true,
     staleAction: "warn",

package/dist/src/config/types.js

@@ -21,6 +21,7 @@ export const AUQConfigSchema = z.object({
     language: z.string().default("auto"),
     theme: z.string().default("system"),
     autoSelectRecommended: z.boolean().default(true),
+    renderer: z.enum(["ink", "opentui"]).default("ink"),
     // Stale/Orphan Session Detection
     staleThreshold: z.number().min(0).default(7200000), // 2 hours in ms
     notifyOnStale: z.boolean().default(true),