auq-mcp-server 0.1.9 → 0.1.24

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

@@ -1,151 +0,0 @@
-import React, { useState, useEffect } from "react";
-import { Box, Text, useInput, useApp } from "ink";
-import { createTUIWatcher } from "../session-watcher.js";
-/**
- * SessionSelectionMenu displays a list of pending question sets and allows user to select one
- * Uses ↑↓ for navigation, Enter to select, q to quit
- */
-export const SessionSelectionMenu = ({ onSessionSelect, }) => {
-    const { exit } = useApp();
-    const [sessions, setSessions] = useState([]);
-    const [selectedIndex, setSelectedIndex] = useState(0);
-    const [isLoading, setIsLoading] = useState(true);
-    const [error, setError] = useState(null);
-    // Load pending sessions on mount and start persistent watcher
-    useEffect(() => {
-        let watcherInstance = null;
-        const initialize = async () => {
-            try {
-                setIsLoading(true);
-                // Step 1: Load existing pending sessions
-                const watcher = createTUIWatcher();
-                const sessionIds = await watcher.getPendingSessions();
-                const sessionData = await Promise.all(sessionIds.map(async (sessionId) => {
-                    const sessionRequest = await watcher.getSessionRequest(sessionId);
-                    if (!sessionRequest)
-                        return null;
-                    return {
-                        sessionId,
-                        sessionRequest,
-                        timestamp: new Date(sessionRequest.timestamp),
-                    };
-                }));
-                // Filter out null entries and sort by timestamp (newest first)
-                const validSessions = sessionData
-                    .filter((s) => s !== null)
-                    .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
-                setSessions(validSessions);
-                setIsLoading(false);
-                // Step 2: Start persistent watcher for new sessions
-                watcherInstance = createTUIWatcher({ autoLoadData: true });
-                watcherInstance.startEnhancedWatching((event) => {
-                    // Add new session to queue (FIFO - append to end)
-                    setSessions((prev) => {
-                        // Check for duplicates
-                        if (prev.some((s) => s.sessionId === event.sessionId)) {
-                            return prev;
-                        }
-                        // Add to end of queue
-                        return [
-                            ...prev,
-                            {
-                                sessionId: event.sessionId,
-                                sessionRequest: event.sessionRequest,
-                                timestamp: new Date(event.timestamp),
-                            },
-                        ];
-                    });
-                });
-            }
-            catch (err) {
-                setError(err instanceof Error ? err.message : "Failed to load question sets");
-                setIsLoading(false);
-            }
-        };
-        initialize();
-        // Cleanup: stop watcher on unmount
-        return () => {
-            if (watcherInstance) {
-                watcherInstance.stop();
-            }
-        };
-    }, []);
-    // Handle keyboard input
-    useInput((input, key) => {
-        if (isLoading)
-            return;
-        if (key.upArrow && sessions.length > 0) {
-            setSelectedIndex((prev) => Math.max(0, prev - 1));
-        }
-        if (key.downArrow && sessions.length > 0) {
-            setSelectedIndex((prev) => Math.min(sessions.length - 1, prev + 1));
-        }
-        if (key.return && sessions[selectedIndex]) {
-            const { sessionId, sessionRequest } = sessions[selectedIndex];
-            onSessionSelect(sessionId, sessionRequest);
-        }
-        if (input === "q") {
-            exit();
-        }
-    });
-    // Loading state
-    if (isLoading) {
-        return (React.createElement(Box, { padding: 1 },
-            React.createElement(Text, null, "Loading question sets...")));
-    }
-    // Error state
-    if (error) {
-        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
-            React.createElement(Text, { color: "red" },
-                "Error: ",
-                error),
-            React.createElement(Text, { dimColor: true }, "Press q to quit")));
-    }
-    // Zero sessions state
-    if (sessions.length === 0) {
-        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
-            React.createElement(Text, { color: "yellow" }, "No pending question sets found."),
-            React.createElement(Text, { dimColor: true }, "Waiting for AI to ask questions..."),
-            React.createElement(Text, { dimColor: true }, "Press q to quit")));
-    }
-    // Session selection menu
-    return (React.createElement(Box, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "cyan" },
-        React.createElement(Text, { bold: true }, "Select a pending question set:"),
-        React.createElement(Box, { marginTop: 1 }),
-        sessions.map((session, idx) => {
-            const isSelected = idx === selectedIndex;
-            const indicator = isSelected ? "→" : " ";
-            const questionCount = session.sessionRequest.questions.length;
-            const relativeTime = formatRelativeTime(session.sessionRequest.timestamp);
-            return (React.createElement(Text, { key: session.sessionId, color: isSelected ? "cyan" : "white" },
-                indicator,
-                " Question Set ",
-                idx + 1,
-                " (",
-                questionCount,
-                " ",
-                questionCount === 1 ? "question" : "questions",
-                ") - ",
-                relativeTime));
-        }),
-        React.createElement(Box, { marginTop: 1 }),
-        React.createElement(Text, { dimColor: true }, "\u2191\u2193 Navigate | Enter Select | q Quit")));
-};
-/**
- * Format timestamp as relative time (e.g., "5m ago", "2h ago")
- */
-function formatRelativeTime(timestamp) {
-    const now = Date.now();
-    const then = new Date(timestamp).getTime();
-    const diffMs = now - then;
-    const diffMins = Math.floor(diffMs / 60000);
-    if (diffMins < 1)
-        return "just now";
-    if (diffMins < 60)
-        return `${diffMins}m ago`;
-    const diffHours = Math.floor(diffMins / 60);
-    if (diffHours < 24)
-        return `${diffHours}h ago`;
-    const diffDays = Math.floor(diffHours / 24);
-    return `${diffDays}d ago`;
-}

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

@@ -1,368 +0,0 @@
-/**
- * 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: [
-            {
-                title: "Language",
-                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?",
-            },
-        ],
-        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
-                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 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();
-        });
-    });
-});