auq-mcp-server 2.2.2 → 2.4.0

package/dist/src/tui/components/__tests__/StepperView.abandoned.test.js

@@ -0,0 +1,160 @@
+import React from "react";
+import { cleanup, render } from "ink-testing-library";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { ConfigProvider } from "../../ConfigContext.js";
+import { ThemeContext } from "../../ThemeContext.js";
+import { darkTheme } from "../../themes/dark.js";
+import { StepperView } from "../StepperView.js";
+const mockThemeValue = {
+    theme: darkTheme,
+    themeName: "AUQ dark",
+    cycleTheme: () => { },
+};
+const sessionRequest = {
+    sessionId: "abandoned-test-session",
+    status: "pending",
+    timestamp: new Date().toISOString(),
+    callId: "call-abandoned-1",
+    questions: [
+        {
+            title: "Language",
+            prompt: "Pick a language",
+            options: [{ label: "TypeScript" }, { label: "Python" }],
+        },
+        {
+            title: "Framework",
+            prompt: "Pick a framework",
+            options: [{ label: "React" }, { label: "Vue" }],
+        },
+    ],
+};
+function renderStepper(props = {}) {
+    return render(React.createElement(ThemeContext.Provider, { value: mockThemeValue },
+        React.createElement(ConfigProvider, null,
+            React.createElement(StepperView, { sessionId: sessionRequest.sessionId, sessionRequest: sessionRequest, ...props }))));
+}
+function getOutput(frame) {
+    return (frame ?? "").replace(/\x1b\[[0-9;]*m/g, "").replace(/\r/g, "");
+}
+afterEach(() => {
+    cleanup();
+    vi.restoreAllMocks();
+});
+describe("StepperView abandoned session confirmation", () => {
+    it("shows abandoned confirmation dialog when isAbandoned is true", async () => {
+        const instance = renderStepper({ isAbandoned: true });
+        await vi.waitFor(() => {
+            const output = getOutput(instance.lastFrame());
+            expect(output).toContain("AI Disconnected");
+        });
+        const output = getOutput(instance.lastFrame());
+        expect(output).toContain("Answer anyway");
+        expect(output).toContain("Cancel");
+        // Should NOT show question content behind the dialog
+        expect(output).not.toContain("Pick a language");
+    });
+    it("does not show abandoned dialog when isAbandoned is false", () => {
+        const instance = renderStepper({ isAbandoned: false });
+        const output = getOutput(instance.lastFrame());
+        expect(output).not.toContain("AI Disconnected");
+        expect(output).toContain("Pick a language");
+    });
+    it("does not show abandoned dialog when isAbandoned is undefined", () => {
+        const instance = renderStepper();
+        const output = getOutput(instance.lastFrame());
+        expect(output).not.toContain("AI Disconnected");
+        expect(output).toContain("Pick a language");
+    });
+    it("selecting 'Answer anyway' dismisses dialog and shows questions", async () => {
+        const instance = renderStepper({ isAbandoned: true });
+        await vi.waitFor(() => {
+            const output = getOutput(instance.lastFrame());
+            expect(output).toContain("AI Disconnected");
+        });
+        // Press Enter to select the first option ("Answer anyway")
+        instance.stdin.write("\r");
+        await vi.waitFor(() => {
+            const output = getOutput(instance.lastFrame());
+            expect(output).toContain("Pick a language");
+        });
+        const output = getOutput(instance.lastFrame());
+        expect(output).not.toContain("AI Disconnected");
+    });
+    it("selecting 'Cancel' calls onAbandonedCancel", async () => {
+        const onAbandonedCancel = vi.fn();
+        const instance = renderStepper({
+            isAbandoned: true,
+            onAbandonedCancel,
+        });
+        await vi.waitFor(() => {
+            const output = getOutput(instance.lastFrame());
+            expect(output).toContain("AI Disconnected");
+        });
+        // Navigate down to "Cancel" then press Enter
+        // Use OA/OB sequences which ink reliably parses as arrows
+        instance.stdin.write("\x1bOB"); // Down arrow (application mode)
+        await new Promise((r) => setTimeout(r, 100));
+        // Press Enter to select "Cancel"
+        instance.stdin.write("\r");
+        await vi.waitFor(() => {
+            expect(onAbandonedCancel).toHaveBeenCalledOnce();
+        });
+    });
+    it("pressing Escape calls onAbandonedCancel", async () => {
+        const onAbandonedCancel = vi.fn();
+        const instance = renderStepper({
+            isAbandoned: true,
+            onAbandonedCancel,
+        });
+        await vi.waitFor(() => {
+            const output = getOutput(instance.lastFrame());
+            expect(output).toContain("AI Disconnected");
+        });
+        // Press Escape
+        instance.stdin.write("\x1b");
+        await vi.waitFor(() => {
+            expect(onAbandonedCancel).toHaveBeenCalledOnce();
+        });
+    });
+    it("after confirming, dialog does not reappear for the same session", async () => {
+        const instance = renderStepper({ isAbandoned: true });
+        // Wait for dialog
+        await vi.waitFor(() => {
+            expect(getOutput(instance.lastFrame())).toContain("AI Disconnected");
+        });
+        // Confirm ("Answer anyway")
+        instance.stdin.write("\r");
+        // Wait for questions to appear
+        await vi.waitFor(() => {
+            expect(getOutput(instance.lastFrame())).toContain("Pick a language");
+        });
+        // The dialog should stay dismissed - verify questions are still shown
+        const output = getOutput(instance.lastFrame());
+        expect(output).toContain("Pick a language");
+        expect(output).not.toContain("AI Disconnected");
+    });
+    it("emits showAbandonedConfirm in onFlowStateChange", async () => {
+        const onFlowStateChange = vi.fn();
+        renderStepper({
+            isAbandoned: true,
+            onFlowStateChange,
+        });
+        await vi.waitFor(() => {
+            expect(onFlowStateChange).toHaveBeenCalledWith(expect.objectContaining({ showAbandonedConfirm: true }));
+        });
+    });
+    it("blocks keyboard navigation while dialog is shown", async () => {
+        const instance = renderStepper({ isAbandoned: true });
+        await vi.waitFor(() => {
+            expect(getOutput(instance.lastFrame())).toContain("AI Disconnected");
+        });
+        // Try Tab to navigate questions - should do nothing
+        instance.stdin.write("\t");
+        // Dialog should still be shown
+        await vi.waitFor(() => {
+            const output = getOutput(instance.lastFrame());
+            expect(output).toContain("AI Disconnected");
+            expect(output).not.toContain("Pick a language");
+        });
+    });
+});

package/dist/src/tui/components/__tests__/StepperView.keyboard.test.js

@@ -0,0 +1,135 @@
+import React from "react";
+import { cleanup, render } from "ink-testing-library";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { ConfigProvider } from "../../ConfigContext.js";
+import { ThemeContext } from "../../ThemeContext.js";
+import { darkTheme } from "../../themes/dark.js";
+import { StepperView } from "../StepperView.js";
+const mockThemeValue = {
+    theme: darkTheme,
+    themeName: "AUQ dark",
+    cycleTheme: () => { },
+};
+const sessionRequest = {
+    sessionId: "kbd-test-session",
+    status: "pending",
+    timestamp: new Date().toISOString(),
+    callId: "call-kbd-1",
+    questions: [
+        {
+            title: "Q1",
+            prompt: "First question?",
+            options: [{ label: "A" }, { label: "B" }],
+            multiSelect: false,
+        },
+        {
+            title: "Q2",
+            prompt: "Second question?",
+            options: [{ label: "C" }, { label: "D" }],
+            multiSelect: false,
+        },
+        {
+            title: "Q3",
+            prompt: "Third question?",
+            options: [{ label: "E" }, { label: "F" }],
+            multiSelect: false,
+        },
+    ],
+};
+function renderStepper(props = {}) {
+    return render(React.createElement(ThemeContext.Provider, { value: mockThemeValue },
+        React.createElement(ConfigProvider, null,
+            React.createElement(StepperView, { sessionId: sessionRequest.sessionId, sessionRequest: sessionRequest, ...props }))));
+}
+function getOutput(frame) {
+    return (frame ?? "").replace(/\x1b\[[0-9;]*m/g, "").replace(/\r/g, "");
+}
+afterEach(() => {
+    cleanup();
+    vi.restoreAllMocks();
+});
+describe("StepperView keyboard shortcuts", () => {
+    it("Escape shows rejection confirmation dialog", async () => {
+        const instance = renderStepper();
+        // Verify we start on question 1
+        let output = getOutput(instance.lastFrame());
+        expect(output).toContain("First question?");
+        // Press Escape
+        instance.stdin.write("\x1b");
+        await vi.waitFor(() => {
+            const out = getOutput(instance.lastFrame());
+            expect(out).toContain("Reject");
+        });
+    });
+    it("Tab navigates to next question", async () => {
+        const instance = renderStepper();
+        // Verify starting on question 1
+        let output = getOutput(instance.lastFrame());
+        expect(output).toContain("First question?");
+        // Press Tab to advance to Q2
+        instance.stdin.write("\t");
+        await vi.waitFor(() => {
+            const out = getOutput(instance.lastFrame());
+            expect(out).toContain("Second question?");
+        });
+    });
+    it("Shift+Tab navigates to previous question", async () => {
+        const onStateSnapshot = vi.fn();
+        const instance = renderStepper({ onStateSnapshot });
+        // First advance to Q2 with Tab
+        instance.stdin.write("\t");
+        await vi.waitFor(() => {
+            const out = getOutput(instance.lastFrame());
+            expect(out).toContain("Second question?");
+        });
+        // Press Shift+Tab (escape sequence for shift-tab in ink)
+        instance.stdin.write("\x1b[Z");
+        await vi.waitFor(() => {
+            const out = getOutput(instance.lastFrame());
+            expect(out).toContain("First question?");
+        });
+    });
+    it("Tab does not navigate past the last question", async () => {
+        const instance = renderStepper();
+        // Navigate to Q3 (last question)
+        instance.stdin.write("\t"); // Q1 -> Q2
+        await vi.waitFor(() => {
+            const out = getOutput(instance.lastFrame());
+            expect(out).toContain("Second question?");
+        });
+        instance.stdin.write("\t"); // Q2 -> Q3
+        await vi.waitFor(() => {
+            const out = getOutput(instance.lastFrame());
+            expect(out).toContain("Third question?");
+        });
+        // Tab again should stay on Q3 (clamped)
+        instance.stdin.write("\t");
+        await vi.waitFor(() => {
+            const out = getOutput(instance.lastFrame());
+            expect(out).toContain("Third question?");
+        });
+    });
+    it("Shift+Tab does not navigate before the first question", async () => {
+        const instance = renderStepper();
+        // Verify on Q1
+        let output = getOutput(instance.lastFrame());
+        expect(output).toContain("First question?");
+        // Press Shift+Tab at Q1 — should remain on Q1
+        instance.stdin.write("\x1b[Z");
+        // Allow state to settle
+        await vi.waitFor(() => {
+            const out = getOutput(instance.lastFrame());
+            expect(out).toContain("First question?");
+        });
+    });
+    it("emits onProgress when Tab advances question", async () => {
+        const onProgress = vi.fn();
+        const instance = renderStepper({ onProgress });
+        // Tab to advance from Q1 to Q2
+        instance.stdin.write("\t");
+        await vi.waitFor(() => {
+            // onProgress should be called with (answered=1, total=3)
+            expect(onProgress).toHaveBeenCalledWith(1, 3);
+        });
+    });
+});

package/dist/src/tui/components/__tests__/StepperView.state.test.js

@@ -96,6 +96,7 @@ describe("StepperView SessionUIState boundary", () => {
         expect(onFlowStateChange).toHaveBeenCalledWith({
             showReview: false,
             showRejectionConfirm: false,
+            showAbandonedConfirm: false,
         });
     });
 });

package/dist/src/tui/components/__tests__/WaitingScreen.test.js

@@ -0,0 +1,60 @@
+import React from "react";
+import { cleanup, render } from "ink-testing-library";
+import { afterEach, describe, expect, it, vi } from "vitest";
+const inputState = vi.hoisted(() => ({
+    handler: null,
+}));
+vi.mock("ink", async () => {
+    const actual = await vi.importActual("ink");
+    return {
+        ...actual,
+        useInput: (handler, options) => {
+            // WaitingScreen calls useInput without options, so always capture
+            if (!options || options.isActive !== false) {
+                inputState.handler = handler;
+            }
+        },
+    };
+});
+// Mock AnimatedGradient to avoid timer/animation side effects
+vi.mock("../AnimatedGradient.js", () => ({
+    AnimatedGradient: ({ text }) => React.createElement("ink-text", null, text),
+}));
+import { ThemeContext } from "../../ThemeContext.js";
+import { darkTheme } from "../../themes/dark.js";
+import { WaitingScreen } from "../WaitingScreen.js";
+const mockThemeValue = {
+    theme: darkTheme,
+    themeName: "AUQ dark",
+    cycleTheme: () => { },
+};
+function renderWithTheme(ui) {
+    return render(React.createElement(ThemeContext.Provider, { value: mockThemeValue }, ui));
+}
+afterEach(() => {
+    cleanup();
+    inputState.handler = null;
+    vi.restoreAllMocks();
+});
+describe("WaitingScreen keyboard handling", () => {
+    it("q key triggers quit", async () => {
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((() => { }));
+        renderWithTheme(React.createElement(WaitingScreen, { queueCount: 0 }));
+        expect(inputState.handler).not.toBeNull();
+        inputState.handler("q", {});
+        await Promise.resolve();
+        expect(exitSpy).toHaveBeenCalledWith(0);
+    });
+    it("Q key (uppercase) triggers quit (case-insensitive)", async () => {
+        const exitSpy = vi
+            .spyOn(process, "exit")
+            .mockImplementation((() => { }));
+        renderWithTheme(React.createElement(WaitingScreen, { queueCount: 0 }));
+        expect(inputState.handler).not.toBeNull();
+        inputState.handler("Q", {});
+        await Promise.resolve();
+        expect(exitSpy).toHaveBeenCalledWith(0);
+    });
+});

package/dist/src/tui/constants/keybindings.js

@@ -0,0 +1,40 @@
+// Keybinding constants for the TUI application
+// All keyboard shortcut definitions are centralized here.
+export const KEYS = {
+    // Session switching (bare keys, no Ctrl)
+    SESSION_NEXT: "]",
+    SESSION_PREV: "[",
+    SESSION_JUMP_MIN: 1,
+    SESSION_JUMP_MAX: 9,
+    // Question navigation
+    RECOMMEND: "r",
+    QUICK_SUBMIT: "r", // used with key.ctrl
+    // Theme
+    THEME_CYCLE: "t", // used with key.ctrl
+    // Confirmation shortcuts
+    CONFIRM_YES: /^[yY]$/,
+    CONFIRM_NO: /^[nN]$/,
+    // Review
+    GO_BACK: /^[nN]$/,
+    // Waiting
+    QUIT: /^[qQ]$/,
+};
+// Display labels for Footer keybinding hints
+export const KEY_LABELS = {
+    SESSION_SWITCH: "]/[",
+    SESSION_LIST: "Ctrl+S",
+    QUICK_SUBMIT: "Ctrl+R",
+    RECOMMEND: "R",
+    THEME: "Ctrl+T",
+    NAVIGATE_QUESTIONS: "←→",
+    NAVIGATE_QUESTIONS_TAB: "Tab/S+Tab",
+    NAVIGATE_OPTIONS: "↑↓",
+    SELECT: "Space",
+    SELECT_NEXT: "Enter",
+    NEXT: "Enter",
+    CURSOR: "←→",
+    NEWLINE: "Enter",
+    REJECT: "Esc",
+    BACK: "n",
+    SUBMIT: "Enter",
+};

package/dist/src/tui/session-watcher.js

@@ -72,6 +72,56 @@ export class EnhancedTUISessionWatcher extends TUISessionWatcher {
             return [];
         }
     }
+    /**
+     * Get pending and abandoned sessions with full status metadata.
+     * Unlike getPendingSessions(), this includes abandoned sessions
+     * and returns status + createdAt for stale detection.
+     */
+    async getPendingSessionsWithStatus() {
+        const fs = await import("fs/promises");
+        const { join } = await import("path");
+        try {
+            const sessionDir = this.watchedPath;
+            const entries = await fs.readdir(sessionDir, { withFileTypes: true });
+            const results = [];
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const sessionPath = join(sessionDir, entry.name);
+                const answersPath = join(sessionPath, SESSION_FILES.ANSWERS);
+                const statusPath = join(sessionPath, SESSION_FILES.STATUS);
+                try {
+                    // Skip sessions that already have answers
+                    await fs.access(answersPath);
+                }
+                catch {
+                    // No answers file — read status.json
+                    try {
+                        const statusContent = await fs.readFile(statusPath, "utf-8");
+                        const status = JSON.parse(statusContent);
+                        // Include pending, in-progress, AND abandoned sessions
+                        if (status.status === "pending" ||
+                            status.status === "in-progress" ||
+                            status.status === "abandoned") {
+                            results.push({
+                                createdAt: status.createdAt,
+                                sessionId: entry.name,
+                                status: status.status,
+                            });
+                        }
+                    }
+                    catch {
+                        // No valid status file — skip
+                    }
+                }
+            }
+            return results.sort((a, b) => a.sessionId.localeCompare(b.sessionId));
+        }
+        catch (error) {
+            console.warn("Failed to scan for pending sessions with status:", error);
+            return [];
+        }
+    }
     /**
      * Get session request data for a specific session
      */

package/dist/src/tui/themes/catppuccin-latte.js

@@ -91,6 +91,7 @@ export const catppuccinLatteTheme = {
             successPillBg: "#dce0e8",
             error: "#d20f39",
             info: "#1e66f5",
+            warning: "#df8e1d",
             border: "#ccd0da",
         },
         markdown: {
@@ -105,6 +106,8 @@ export const catppuccinLatteTheme = {
             untouched: "#acb0c0",
             number: "#4c4f69",
             activeNumber: "#1e66f5",
+            stale: "#df8e1d",
+            abandoned: "#d20f39",
         },
         sessionPicker: {
             border: "#1e66f5",
@@ -115,6 +118,10 @@ export const catppuccinLatteTheme = {
             highlightFg: "#40a02b",
             activeMark: "#1e66f5",
             progress: "#04a5e5",
+            staleIcon: "#df8e1d",
+            staleText: "#df8e1d",
+            staleAge: "#df8e1d",
+            staleSubtitle: "#acb0c0",
         },
     },
 };

package/dist/src/tui/themes/catppuccin-mocha.js

@@ -91,6 +91,7 @@ export const catppuccinMochaTheme = {
             successPillBg: "#313244",
             error: "#f38ba8",
             info: "#89b4fa",
+            warning: "#f9e2af",
             border: "#313244",
         },
         markdown: {
@@ -105,6 +106,8 @@ export const catppuccinMochaTheme = {
             untouched: "#8688a0",
             number: "#cdd6f4",
             activeNumber: "#89b4fa",
+            stale: "#f9e2af",
+            abandoned: "#f38ba8",
         },
         sessionPicker: {
             border: "#89b4fa",
@@ -115,6 +118,10 @@ export const catppuccinMochaTheme = {
             highlightFg: "#a6e3a1",
             activeMark: "#89b4fa",
             progress: "#89dceb",
+            staleIcon: "#f9e2af",
+            staleText: "#f9e2af",
+            staleAge: "#f9e2af",
+            staleSubtitle: "#8688a0",
         },
     },
 };

package/dist/src/tui/themes/dark.js

@@ -92,6 +92,7 @@ export const darkTheme = {
             successPillBg: "#0F2417",
             error: "#FF5C57",
             info: "#46D9FF",
+            warning: "#FFD36A",
             border: "#2A3238",
         },
         markdown: {
@@ -106,6 +107,8 @@ export const darkTheme = {
             untouched: "#A0AAB4",
             number: "#E7EEF5",
             activeNumber: "#46D9FF",
+            stale: "#FFD36A",
+            abandoned: "#FF5C57",
         },
         sessionPicker: {
             border: "#46D9FF",
@@ -116,6 +119,10 @@ export const darkTheme = {
             highlightFg: "#5AF78E",
             activeMark: "#46D9FF",
             progress: "#46D9FF",
+            staleIcon: "#FFD36A",
+            staleText: "#FFD36A",
+            staleAge: "#FFD36A",
+            staleSubtitle: "#A0AAB4",
         },
     },
 };

package/dist/src/tui/themes/dracula.js

@@ -91,6 +91,7 @@ export const draculaTheme = {
             successPillBg: "#44475a", // current line
             error: "#ff5555",
             info: "#bd93f9",
+            warning: "#f1fa8c",
             border: "#44475a",
         },
         markdown: {
@@ -105,6 +106,8 @@ export const draculaTheme = {
             untouched: "#7C8BBE",
             number: "#f8f8f2",
             activeNumber: "#bd93f9",
+            stale: "#f1fa8c",
+            abandoned: "#ff5555",
         },
         sessionPicker: {
             border: "#bd93f9",
@@ -115,6 +118,10 @@ export const draculaTheme = {
             highlightFg: "#50fa7b",
             activeMark: "#bd93f9",
             progress: "#8be9fd",
+            staleIcon: "#f1fa8c",
+            staleText: "#f1fa8c",
+            staleAge: "#f1fa8c",
+            staleSubtitle: "#7C8BBE",
         },
     },
 };

package/dist/src/tui/themes/github-dark.js

@@ -90,6 +90,7 @@ export const githubDarkTheme = {
             successPillBg: "#161b22",
             error: "#f85149",
             info: "#58a6ff",
+            warning: "#d29922",
             border: "#30363d",
         },
         markdown: {
@@ -104,6 +105,8 @@ export const githubDarkTheme = {
             untouched: "#a0a8b4",
             number: "#c9d1d9",
             activeNumber: "#58a6ff",
+            stale: "#d29922",
+            abandoned: "#f85149",
         },
         sessionPicker: {
             border: "#58a6ff",
@@ -114,6 +117,10 @@ export const githubDarkTheme = {
             highlightFg: "#3fb950",
             activeMark: "#58a6ff",
             progress: "#58a6ff",
+            staleIcon: "#d29922",
+            staleText: "#d29922",
+            staleAge: "#d29922",
+            staleSubtitle: "#a0a8b4",
         },
     },
 };

package/dist/src/tui/themes/github-light.js

@@ -90,6 +90,7 @@ export const githubLightTheme = {
             successPillBg: "#f6f8fa",
             error: "#CF222E",
             info: "#0969DA",
+            warning: "#9A6700",
             border: "#D0D7DE",
         },
         markdown: {
@@ -104,6 +105,8 @@ export const githubLightTheme = {
             untouched: "#6E7781",
             number: "#24292F",
             activeNumber: "#0969DA",
+            stale: "#9A6700",
+            abandoned: "#CF222E",
         },
         sessionPicker: {
             border: "#0969DA",
@@ -114,6 +117,10 @@ export const githubLightTheme = {
             highlightFg: "#1A7F37",
             activeMark: "#0969DA",
             progress: "#0969DA",
+            staleIcon: "#9A6700",
+            staleText: "#9A6700",
+            staleAge: "#9A6700",
+            staleSubtitle: "#6E7781",
         },
     },
 };

package/dist/src/tui/themes/gruvbox-dark.js

@@ -91,6 +91,7 @@ export const gruvboxDarkTheme = {
             successPillBg: "#3c3836", // dark1
             error: "#cc241d",
             info: "#458588",
+            warning: "#d79921",
             border: "#3c3836",
         },
         markdown: {
@@ -105,6 +106,8 @@ export const gruvboxDarkTheme = {
             untouched: "#a89984",
             number: "#ebdbb2",
             activeNumber: "#458588",
+            stale: "#d79921",
+            abandoned: "#cc241d",
         },
         sessionPicker: {
             border: "#458588",
@@ -115,6 +118,10 @@ export const gruvboxDarkTheme = {
             highlightFg: "#98971a",
             activeMark: "#458588",
             progress: "#458588",
+            staleIcon: "#d79921",
+            staleText: "#d79921",
+            staleAge: "#d79921",
+            staleSubtitle: "#a89984",
         },
     },
 };