auq-mcp-server 0.1.0

package/dist/src/session/utils.js

@@ -0,0 +1,180 @@
+/**
+ * Utility functions for session management
+ */
+import { constants, existsSync } from "fs";
+import { promises as fs } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { fileURLToPath } from "url";
+/**
+ * Create a safe filename from a session ID (basic validation)
+ */
+export function createSafeFilename(sessionId, filename) {
+    if (!sanitizeSessionId(sessionId)) {
+        throw new Error(`Invalid session ID format: ${sessionId}`);
+    }
+    return filename;
+}
+/**
+ * Ensure a directory exists with proper permissions
+ */
+export async function ensureDirectoryExists(dirPath) {
+    try {
+        await fs.access(dirPath, constants.W_OK);
+    }
+    catch {
+        await fs.mkdir(dirPath, { mode: 0o700, recursive: true });
+    }
+}
+/**
+ * Check if a file exists and is readable
+ */
+export async function fileExists(filePath) {
+    try {
+        await fs.access(filePath, constants.R_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the current timestamp in ISO format
+ */
+export function getCurrentTimestamp() {
+    return new Date().toISOString();
+}
+/**
+ * Check if a timestamp is older than the specified timeout in milliseconds
+ */
+export function isTimestampExpired(timestamp, timeoutMs) {
+    const now = new Date().getTime();
+    const timestampTime = new Date(timestamp).getTime();
+    return now - timestampTime > timeoutMs;
+}
+/**
+ * Resolve session directory path using XDG Base Directory specification
+ * Falls back to user home directory if XDG is not available
+ */
+export function resolveSessionDirectory(baseDir) {
+    if (baseDir) {
+        // If baseDir is provided, expand any ~ to home directory
+        if (baseDir.startsWith("~")) {
+            return join(homedir(), baseDir.slice(1));
+        }
+        return baseDir;
+    }
+    // Default XDG-compliant paths
+    const home = homedir();
+    const platform = process.platform;
+    if (platform === "darwin") {
+        // macOS: ~/Library/Application Support/
+        return join(home, "Library", "Application Support", "auq", "sessions");
+    }
+    else if (platform === "win32") {
+        // Windows: %APPDATA%/auq/sessions/
+        const appData = process.env.APPDATA;
+        if (appData) {
+            return join(appData, "auq", "sessions");
+        }
+        // Fallback to user profile
+        const userProfile = process.env.USERPROFILE || home;
+        return join(userProfile, "auq", "sessions");
+    }
+    else {
+        // Linux/Unix: ~/.local/share/ (XDG Base Directory)
+        // Check for XDG_DATA_HOME environment variable
+        const xdgDataHome = process.env.XDG_DATA_HOME;
+        if (xdgDataHome) {
+            return join(xdgDataHome, "auq", "sessions");
+        }
+        // Fallback to ~/.local/share/
+        return join(home, ".local", "share", "auq", "sessions");
+    }
+}
+/**
+ * Safely parse JSON with error handling
+ */
+export function safeJsonParse(json, fallback) {
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return fallback;
+    }
+}
+/**
+ * Validate that a session ID follows UUID v4 format
+ */
+export function sanitizeSessionId(sessionId) {
+    // Basic validation - UUID v4 format
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    return uuidRegex.test(sessionId);
+}
+/**
+ * Validate that a session directory exists and is accessible
+ */
+export async function validateSessionDirectory(baseDir) {
+    try {
+        await fs.access(baseDir, constants.R_OK | constants.W_OK);
+        const stat = await fs.stat(baseDir);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Detect whether AUQ is installed globally or locally
+ * by inspecting the module's location
+ */
+export function detectInstallMode() {
+    try {
+        // Get current module's file path
+        const __filename = fileURLToPath(import.meta.url);
+        const parts = __filename.split(/[/\\]/); // Handle both Unix and Windows separators
+        // Find the last occurrence of 'node_modules' in the path
+        const nodeModulesIndex = parts.lastIndexOf("node_modules");
+        if (nodeModulesIndex === -1) {
+            // Not in node_modules (development or global install without node_modules in path)
+            return { mode: "global" };
+        }
+        // We're inside node_modules - check if there's a project package.json above
+        const potentialProjectRoot = parts.slice(0, nodeModulesIndex).join("/");
+        const packageJsonPath = join(potentialProjectRoot, "package.json");
+        if (existsSync(packageJsonPath)) {
+            // Found a package.json above node_modules → local install
+            return { mode: "local", projectRoot: potentialProjectRoot };
+        }
+        // In node_modules but no project context → global install
+        return { mode: "global" };
+    }
+    catch (error) {
+        // Fallback to global mode if detection fails
+        console.error("[AUQ] Failed to detect install mode:", error);
+        return { mode: "global" };
+    }
+}
+/**
+ * Get the appropriate session directory based on installation mode
+ * Supports environment variable override via AUQ_SESSION_DIR
+ */
+export function getSessionDirectory() {
+    // Check for environment variable override first
+    if (process.env.AUQ_SESSION_DIR) {
+        const envDir = process.env.AUQ_SESSION_DIR;
+        // Expand ~ to home directory if needed
+        if (envDir.startsWith("~")) {
+            return join(homedir(), envDir.slice(1));
+        }
+        return envDir;
+    }
+    // Auto-detect installation mode
+    const { mode, projectRoot } = detectInstallMode();
+    if (mode === "local" && projectRoot) {
+        // Local install: use project-relative .auq/sessions directory
+        return join(projectRoot, ".auq", "sessions");
+    }
+    // Global install: use XDG-compliant system paths
+    return resolveSessionDirectory();
+}

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

@@ -0,0 +1,368 @@
+/**
+ * Unit tests for TUI session watcher functionality
+ */
+import { promises as fs } from "fs";
+import { join } from "path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { SESSION_FILES } from "../../session/types.js";
+import { createTUIWatcher, EnhancedTUISessionWatcher, getNextPendingSession, } from "../session-watcher.js";
+describe("TUI Session Watcher", () => {
+    const testDir = "/tmp/auq-tui-watcher-test";
+    const sessionDir = join(testDir, "sessions");
+    const testSessionId = "test-session-123";
+    const mockSessionRequest = {
+        questions: [
+            {
+                options: [
+                    { description: "Dynamic web language", label: "JavaScript" },
+                    { description: "Typed JavaScript", label: "TypeScript" },
+                    { description: "Versatile and readable", label: "Python" },
+                ],
+                prompt: "What is your favorite programming language?",
+                title: "Language",
+            },
+        ],
+        sessionId: testSessionId,
+        status: "pending",
+        timestamp: new Date().toISOString(),
+    };
+    beforeEach(async () => {
+        // Clean up test directory before each test
+        await fs.rm(testDir, { force: true, recursive: true }).catch(() => { });
+        await fs.mkdir(sessionDir, { recursive: true });
+    });
+    afterEach(async () => {
+        // Clean up test directory after each test
+        await fs.rm(testDir, { force: true, recursive: true }).catch(() => { });
+    });
+    describe("EnhancedTUISessionWatcher", () => {
+        describe("session event detection", () => {
+            it("should detect new sessions with loaded data", async () => {
+                const watcher = new EnhancedTUISessionWatcher({
+                    autoLoadData: true,
+                    debounceMs: 100,
+                    sessionDir,
+                });
+                const events = [];
+                watcher.startEnhancedWatching((event) => {
+                    events.push(event);
+                });
+                // Give watcher time to initialize
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                // Create a new session directory
+                const newSessionDir = join(sessionDir, testSessionId);
+                await fs.mkdir(newSessionDir);
+                // Create required session files
+                const requestFile = join(newSessionDir, SESSION_FILES.REQUEST);
+                const statusFile = join(newSessionDir, SESSION_FILES.STATUS);
+                await Promise.all([
+                    fs.writeFile(requestFile, JSON.stringify(mockSessionRequest, null, 2)),
+                    fs.writeFile(statusFile, JSON.stringify({
+                        createdAt: new Date().toISOString(),
+                        lastModified: new Date().toISOString(),
+                        sessionId: testSessionId,
+                        status: "pending",
+                        totalQuestions: 1,
+                    })),
+                ]);
+                // Wait for debounce (100ms) + processing time
+                await new Promise((resolve) => setTimeout(resolve, 300));
+                expect(events).toHaveLength(1);
+                expect(events[0].type).toBe("session-created");
+                expect(events[0].sessionId).toBe(testSessionId);
+                expect(events[0].sessionRequest).toEqual(mockSessionRequest);
+                watcher.stop();
+            });
+            it("should handle autoLoadData disabled", async () => {
+                const watcher = new EnhancedTUISessionWatcher({
+                    autoLoadData: false,
+                    debounceMs: 100,
+                    sessionDir,
+                });
+                const events = [];
+                watcher.startEnhancedWatching((event) => {
+                    events.push(event);
+                });
+                // Give watcher time to initialize
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                // Create session directory and files
+                const newSessionDir = join(sessionDir, testSessionId);
+                await fs.mkdir(newSessionDir);
+                const requestFile = join(newSessionDir, SESSION_FILES.REQUEST);
+                await fs.writeFile(requestFile, JSON.stringify(mockSessionRequest, null, 2));
+                // Wait for debounce + processing
+                await new Promise((resolve) => setTimeout(resolve, 300));
+                expect(events).toHaveLength(1);
+                expect(events[0].type).toBe("session-created");
+                expect(events[0].sessionId).toBe(testSessionId);
+                expect(events[0].sessionRequest).toBeUndefined(); // Should not be loaded
+                watcher.stop();
+            });
+            it("should handle corrupted session files gracefully", async () => {
+                const watcher = new EnhancedTUISessionWatcher({
+                    autoLoadData: true,
+                    debounceMs: 100,
+                    sessionDir,
+                });
+                const events = [];
+                const consoleSpy = vi
+                    .spyOn(console, "warn")
+                    .mockImplementation(() => { });
+                watcher.startEnhancedWatching((event) => {
+                    events.push(event);
+                });
+                // Create session with corrupted request.json
+                const newSessionDir = join(sessionDir, testSessionId);
+                await fs.mkdir(newSessionDir);
+                const requestFile = join(newSessionDir, SESSION_FILES.REQUEST);
+                const statusFile = join(newSessionDir, SESSION_FILES.STATUS);
+                // Write corrupted request.json and valid status.json
+                await Promise.all([
+                    fs.writeFile(requestFile, "invalid json content"),
+                    fs.writeFile(statusFile, JSON.stringify({
+                        createdAt: new Date().toISOString(),
+                        lastModified: new Date().toISOString(),
+                        sessionId: testSessionId,
+                        status: "pending",
+                        totalQuestions: 1,
+                    })),
+                ]);
+                // Wait for debounce + processing (increased for reliability)
+                await new Promise((resolve) => setTimeout(resolve, 500));
+                expect(events).toHaveLength(1);
+                expect(events[0].type).toBe("session-created");
+                expect(events[0].sessionId).toBe(testSessionId);
+                expect(events[0].sessionRequest).toBeUndefined();
+                // Should have logged a warning about corrupted data
+                expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to load session request"), expect.any(Error));
+                consoleSpy.mockRestore();
+                watcher.stop();
+            });
+        });
+        describe("event handlers", () => {
+            it("should support multiple event handlers", async () => {
+                const watcher = new EnhancedTUISessionWatcher({
+                    debounceMs: 100,
+                    sessionDir,
+                });
+                const mainEvents = [];
+                const customEvents = [];
+                watcher.addEventHandler("custom", (event) => {
+                    customEvents.push(event);
+                });
+                watcher.startEnhancedWatching((event) => {
+                    mainEvents.push(event);
+                });
+                // Give watcher time to initialize
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                // Create session
+                const newSessionDir = join(sessionDir, testSessionId);
+                await fs.mkdir(newSessionDir);
+                const requestFile = join(newSessionDir, SESSION_FILES.REQUEST);
+                await fs.writeFile(requestFile, JSON.stringify(mockSessionRequest, null, 2));
+                // Wait for debounce + processing
+                await new Promise((resolve) => setTimeout(resolve, 300));
+                expect(mainEvents).toHaveLength(1);
+                expect(customEvents).toHaveLength(1);
+                expect(customEvents[0]).toEqual(mainEvents[0]);
+                watcher.removeEventHandler("custom");
+                watcher.stop();
+            });
+            it("should handle event handler removal", async () => {
+                const watcher = new EnhancedTUISessionWatcher({ sessionDir });
+                const customEvents = [];
+                watcher.addEventHandler("custom", (event) => {
+                    customEvents.push(event);
+                });
+                watcher.removeEventHandler("custom");
+                watcher.startEnhancedWatching(() => { });
+                // Create session
+                const newSessionDir = join(sessionDir, testSessionId);
+                await fs.mkdir(newSessionDir);
+                const requestFile = join(newSessionDir, SESSION_FILES.REQUEST);
+                await fs.writeFile(requestFile, JSON.stringify(mockSessionRequest, null, 2));
+                // Wait for processing
+                await new Promise((resolve) => setTimeout(resolve, 100));
+                expect(customEvents).toHaveLength(0); // Should not have triggered
+                watcher.stop();
+            });
+        });
+        describe("session management", () => {
+            beforeEach(async () => {
+                // Create multiple test sessions
+                const sessions = [
+                    { completed: false, id: "session-1" },
+                    { completed: true, id: "session-2" },
+                    { completed: false, id: "session-3" },
+                ];
+                for (const session of sessions) {
+                    const sessionDir = join(testDir, "sessions", session.id);
+                    await fs.mkdir(sessionDir, { recursive: true });
+                    // Create request.json
+                    const requestFile = join(sessionDir, SESSION_FILES.REQUEST);
+                    await fs.writeFile(requestFile, JSON.stringify({
+                        ...mockSessionRequest,
+                        sessionId: session.id,
+                    }));
+                    // Create status.json
+                    const statusFile = join(sessionDir, SESSION_FILES.STATUS);
+                    await fs.writeFile(statusFile, JSON.stringify({
+                        createdAt: new Date().toISOString(),
+                        lastModified: new Date().toISOString(),
+                        sessionId: session.id,
+                        status: session.completed ? "completed" : "pending",
+                        totalQuestions: 1,
+                    }));
+                    // Create answers.json for completed sessions
+                    if (session.completed) {
+                        const answersFile = join(sessionDir, SESSION_FILES.ANSWERS);
+                        await fs.writeFile(answersFile, JSON.stringify({
+                            answers: [
+                                {
+                                    questionIndex: 0,
+                                    selectedOption: "JavaScript",
+                                    timestamp: new Date().toISOString(),
+                                },
+                            ],
+                            sessionId: session.id,
+                            timestamp: new Date().toISOString(),
+                        }));
+                    }
+                }
+            });
+            it("should get pending sessions correctly", async () => {
+                const watcher = new EnhancedTUISessionWatcher({ sessionDir });
+                const pendingSessions = await watcher.getPendingSessions();
+                expect(pendingSessions).toHaveLength(2);
+                expect(pendingSessions).toContain("session-1");
+                expect(pendingSessions).toContain("session-3");
+                expect(pendingSessions).not.toContain("session-2");
+                // Should be sorted
+                expect(pendingSessions[0]).toBe("session-1");
+                expect(pendingSessions[1]).toBe("session-3");
+                watcher.stop();
+            });
+            it("should get session request data", async () => {
+                const watcher = new EnhancedTUISessionWatcher({ sessionDir });
+                const sessionRequest = await watcher.getSessionRequest("session-1");
+                expect(sessionRequest).toBeTruthy();
+                expect(sessionRequest?.sessionId).toBe("session-1");
+                expect(sessionRequest?.questions).toHaveLength(1);
+                watcher.stop();
+            });
+            it("should handle non-existent session request", async () => {
+                const watcher = new EnhancedTUISessionWatcher({ sessionDir });
+                const consoleSpy = vi
+                    .spyOn(console, "warn")
+                    .mockImplementation(() => { });
+                const sessionRequest = await watcher.getSessionRequest("non-existent");
+                expect(sessionRequest).toBeNull();
+                expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to load session request"), expect.any(Error));
+                consoleSpy.mockRestore();
+                watcher.stop();
+            });
+            it("should check session pending status correctly", async () => {
+                const watcher = new EnhancedTUISessionWatcher({ sessionDir });
+                expect(await watcher.isSessionPending("session-1")).toBe(true);
+                expect(await watcher.isSessionPending("session-2")).toBe(false);
+                expect(await watcher.isSessionPending("session-3")).toBe(true);
+                expect(await watcher.isSessionPending("non-existent")).toBe(false);
+                watcher.stop();
+            });
+        });
+    });
+    describe("Utility Functions", () => {
+        describe("createTUIWatcher", () => {
+            it("should create an enhanced TUI session watcher", () => {
+                const watcher = createTUIWatcher({ sessionDir });
+                expect(watcher).toBeInstanceOf(EnhancedTUISessionWatcher);
+                expect(watcher.watchedPath).toBe(sessionDir);
+                watcher.stop();
+            });
+        });
+        describe("getNextPendingSession", () => {
+            beforeEach(async () => {
+                // Create test sessions
+                const sessions = [
+                    { id: "first-session", pending: true },
+                    { id: "second-session", pending: true },
+                ];
+                for (const session of sessions) {
+                    const sessionDir = join(testDir, "sessions", session.id);
+                    await fs.mkdir(sessionDir, { recursive: true });
+                    // Create required files
+                    const requestFile = join(sessionDir, SESSION_FILES.REQUEST);
+                    const statusFile = join(sessionDir, SESSION_FILES.STATUS);
+                    await Promise.all([
+                        fs.writeFile(requestFile, JSON.stringify({
+                            ...mockSessionRequest,
+                            sessionId: session.id,
+                        })),
+                        fs.writeFile(statusFile, JSON.stringify({
+                            createdAt: new Date().toISOString(),
+                            lastModified: new Date().toISOString(),
+                            sessionId: session.id,
+                            status: "pending",
+                            totalQuestions: 1,
+                        })),
+                    ]);
+                }
+            });
+            it("should get the next pending session", async () => {
+                const result = await getNextPendingSession({ sessionDir });
+                expect(result).toBeTruthy();
+                expect(result?.sessionId).toBe("first-session");
+                expect(result?.sessionRequest).toBeTruthy();
+                expect(result?.sessionRequest.sessionId).toBe("first-session");
+            });
+            it("should return null when no pending sessions", async () => {
+                // Clear all sessions
+                await fs.rm(sessionDir, { recursive: true });
+                await fs.mkdir(sessionDir);
+                const result = await getNextPendingSession({ sessionDir });
+                expect(result).toBeNull();
+            });
+            it("should handle sessions with corrupted data", async () => {
+                // Create session with corrupted request.json
+                const corruptedSessionDir = join(sessionDir, "corrupted-session");
+                await fs.mkdir(corruptedSessionDir);
+                const statusFile = join(corruptedSessionDir, SESSION_FILES.STATUS);
+                await fs.writeFile(statusFile, JSON.stringify({
+                    createdAt: new Date().toISOString(),
+                    lastModified: new Date().toISOString(),
+                    sessionId: "corrupted-session",
+                    status: "pending",
+                    totalQuestions: 1,
+                }));
+                // Create corrupted request.json
+                const requestFile = join(corruptedSessionDir, SESSION_FILES.REQUEST);
+                await fs.writeFile(requestFile, "invalid json");
+                const result = await getNextPendingSession({ sessionDir });
+                // Should skip corrupted session and return valid one
+                expect(result).toBeTruthy();
+                expect(result?.sessionId).toBe("first-session");
+            });
+        });
+    });
+    describe("Error Handling", () => {
+        it("should handle directory access errors", async () => {
+            const watcher = new EnhancedTUISessionWatcher({
+                sessionDir: "/invalid/directory/path",
+            });
+            const consoleSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
+            const pendingSessions = await watcher.getPendingSessions();
+            expect(pendingSessions).toEqual([]);
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to scan for pending sessions"), expect.any(Error));
+            consoleSpy.mockRestore();
+            watcher.stop();
+        });
+        it("should handle missing watched path gracefully", async () => {
+            const watcher = new EnhancedTUISessionWatcher({
+                sessionDir: "/non/existent/path",
+            });
+            const sessionRequest = await watcher.getSessionRequest("any-id");
+            expect(sessionRequest).toBeNull();
+            watcher.stop();
+        });
+    });
+});

package/dist/src/tui/components/AnimatedGradient.js

@@ -0,0 +1,45 @@
+import { Text } from "ink";
+import gradient from "gradient-string";
+import React, { useEffect, useState } from "react";
+/**
+ * AnimatedGradient component - creates the smoothest possible flowing gradient effect
+ * Uses high-frequency updates (60 FPS) with many color stops for visible smoothness
+ * The gradient flows from right to left
+ */
+export const AnimatedGradient = ({ text, flowSpeed = 0.3, // Speed of flow
+ }) => {
+    const [frame, setFrame] = useState(0);
+    // Generate a large color palette with many intermediate shades for smooth transitions
+    const generateColorStops = (numStops = 100) => {
+        const stops = [];
+        for (let i = 0; i < numStops; i++) {
+            const t = i / numStops;
+            // Create a wave pattern with sparse white peaks (2 peaks across the gradient)
+            const wave = Math.sin(t * Math.PI * 2 * 2) * 0.5 + 0.5;
+            // Apply power function to make white peaks sharper and briefer
+            const sharpWave = Math.pow(wave, 4); // Quartic power makes whites very brief
+            // Interpolate between light gray (175) and white (255)
+            const value = Math.floor(175 + (255 - 175) * sharpWave);
+            const hex = value.toString(16).padStart(2, "0");
+            stops.push(`#${hex}${hex}${hex}`);
+        }
+        return stops;
+    };
+    const colors = generateColorStops(100);
+    useEffect(() => {
+        // Run at 60 FPS for smooth updates - reversed direction
+        const interval = setInterval(() => {
+            setFrame((prev) => (prev - flowSpeed + colors.length) % colors.length);
+        }, 1000 / 60);
+        return () => clearInterval(interval);
+    }, [colors.length, flowSpeed]);
+    // Rotate colors array based on current frame to create flowing effect
+    const frameIndex = Math.floor(frame);
+    const rotatedColors = [
+        ...colors.slice(frameIndex),
+        ...colors.slice(0, frameIndex),
+    ];
+    const gradientFn = gradient(rotatedColors);
+    const styledText = gradientFn(text);
+    return React.createElement(Text, null, styledText);
+};

package/dist/src/tui/components/ConfirmationDialog.js

@@ -0,0 +1,89 @@
+import { Box, Text, useInput } from "ink";
+import React, { useState } from "react";
+import { theme } from "../theme.js";
+import { MultiLineTextInput } from "./MultiLineTextInput.js";
+/**
+ * ConfirmationDialog shows a 3-option prompt for session rejection
+ * Options: Reject & inform AI, Cancel, or Quit CLI
+ * If user chooses to reject, shows a two-step flow to optionally collect rejection reason
+ */
+export const ConfirmationDialog = ({ message, onReject, onCancel, onQuit, }) => {
+    const [focusedIndex, setFocusedIndex] = useState(0);
+    const [showReasonInput, setShowReasonInput] = useState(false);
+    const [rejectionReason, setRejectionReason] = useState("");
+    const handleReasonSubmit = () => {
+        onReject(rejectionReason.trim() || null);
+    };
+    const handleSkipReason = () => {
+        onReject(null);
+    };
+    const options = [
+        { key: "y", label: "Yes, inform the AI that I rejected this question set", action: () => setShowReasonInput(true) },
+        { key: "n", label: "No, go back to answering questions", action: onCancel },
+        { key: "q", label: "I'm just trying to quit the CLI, I'll answer later", action: onQuit },
+    ];
+    useInput((input, key) => {
+        // If in reason input mode, handle Esc to skip
+        if (showReasonInput) {
+            if (key.escape) {
+                handleSkipReason();
+            }
+            return; // Let MultiLineTextInput handle other keys
+        }
+        // Arrow key navigation
+        if (key.upArrow) {
+            setFocusedIndex((prev) => (prev > 0 ? prev - 1 : options.length - 1));
+        }
+        if (key.downArrow) {
+            setFocusedIndex((prev) => (prev < options.length - 1 ? prev + 1 : 0));
+        }
+        // Enter key - select focused option
+        if (key.return) {
+            options[focusedIndex].action();
+        }
+        // Letter shortcuts
+        if (input === "y" || input === "Y") {
+            setShowReasonInput(true);
+        }
+        if (input === "n" || input === "N") {
+            onCancel();
+        }
+        if (input === "q" || input === "Q") {
+            onQuit();
+        }
+        // Esc key - same as quit
+        if (key.escape) {
+            onQuit();
+        }
+    });
+    // Step 2: Reason input screen
+    if (showReasonInput) {
+        return (React.createElement(Box, { borderColor: theme.borders.warning, borderStyle: "single", flexDirection: "column", padding: 1 },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: theme.colors.warning }, "Why are you rejecting this question set?")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { dimColor: true }, "(Optional - helps the AI improve)")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(MultiLineTextInput, { isFocused: true, onChange: setRejectionReason, onSubmit: handleReasonSubmit, placeholder: "Type your reason here...", value: rejectionReason })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Enter Submit | Shift+Enter Newline | Esc Skip"))));
+    }
+    // Step 1: Confirmation options
+    return (React.createElement(Box, { borderColor: theme.borders.warning, borderStyle: "single", flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: theme.colors.warning }, message)),
+        options.map((option, index) => {
+            const isFocused = index === focusedIndex;
+            return (React.createElement(Box, { key: index, marginTop: index > 0 ? 0.5 : 0 },
+                React.createElement(Text, { bold: isFocused, color: isFocused ? theme.colors.focused : theme.colors.text },
+                    isFocused ? "→ " : "  ",
+                    index + 1,
+                    ". ",
+                    option.label,
+                    " (",
+                    option.key,
+                    ")")));
+        }),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true }, "\u2191\u2193 Navigate | Enter Select | y/n/q Shortcuts"))));
+};