auq-mcp-server 0.1.0

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

@@ -0,0 +1,166 @@
+import { Box, Text, useApp, useInput } from "ink";
+import React, { useEffect, useRef, useState } from "react";
+import { SessionManager } from "../../session/SessionManager.js";
+import { theme } from "../theme.js";
+import { ConfirmationDialog } from "./ConfirmationDialog.js";
+import { QuestionDisplay } from "./QuestionDisplay.js";
+import { ReviewScreen } from "./ReviewScreen.js";
+/**
+ * StepperView orchestrates the question-answering flow
+ * Manages state for current question, answers, and navigation
+ */
+export const StepperView = ({ onComplete, sessionId, sessionRequest, }) => {
+    const { exit } = useApp();
+    const [currentQuestionIndex, setCurrentQuestionIndex] = useState(0);
+    const [answers, setAnswers] = useState(new Map());
+    const [showReview, setShowReview] = useState(false);
+    const [submitting, setSubmitting] = useState(false);
+    const [showRejectionConfirm, setShowRejectionConfirm] = useState(false);
+    const currentQuestion = sessionRequest.questions[currentQuestionIndex];
+    // Handle option selection
+    const handleSelectOption = (label) => {
+        setAnswers((prev) => {
+            const newAnswers = new Map(prev);
+            const existing = newAnswers.get(currentQuestionIndex) || {};
+            newAnswers.set(currentQuestionIndex, {
+                ...existing,
+                selectedOption: label,
+            });
+            return newAnswers;
+        });
+    };
+    const handleToggleOption = (label) => {
+        setAnswers((prev) => {
+            const newAnswers = new Map(prev);
+            const existing = newAnswers.get(currentQuestionIndex) || {};
+            const currentSelections = existing.selectedOptions || [];
+            const newSelections = currentSelections.includes(label)
+                ? currentSelections.filter((l) => l !== label) // Remove if already selected
+                : [...currentSelections, label]; // Add if not selected
+            newAnswers.set(currentQuestionIndex, {
+                selectedOptions: newSelections,
+                // Keep customText in multi-select mode (allow both)
+                customText: existing.customText,
+            });
+            return newAnswers;
+        });
+    };
+    // Handle custom answer text
+    const handleChangeCustomAnswer = (text) => {
+        setAnswers((prev) => {
+            const newAnswers = new Map(prev);
+            const existing = newAnswers.get(currentQuestionIndex) || {};
+            newAnswers.set(currentQuestionIndex, {
+                ...existing,
+                customText: text,
+            });
+            return newAnswers;
+        });
+    };
+    // Track mount status to avoid state updates after unmount
+    const isMountedRef = useRef(true);
+    useEffect(() => {
+        isMountedRef.current = true;
+        return () => {
+            isMountedRef.current = false;
+        };
+    }, []);
+    // Reset internal stepper state when the session changes (safety in case component isn't remounted)
+    useEffect(() => {
+        setCurrentQuestionIndex(0);
+        setAnswers(new Map());
+        setShowReview(false);
+        setSubmitting(false);
+        setShowRejectionConfirm(false);
+    }, [sessionId]);
+    // Handle answer confirmation
+    const handleConfirm = async (userAnswers) => {
+        setSubmitting(true);
+        try {
+            const sessionManager = new SessionManager();
+            await sessionManager.saveSessionAnswers(sessionId, {
+                answers: userAnswers,
+                sessionId,
+                timestamp: new Date().toISOString(),
+                callId: sessionRequest.callId,
+            });
+            // Signal completion (successful submission)
+            onComplete?.(false);
+        }
+        catch (error) {
+            console.error("Failed to save answers:", error);
+        }
+        finally {
+            if (isMountedRef.current) {
+                setSubmitting(false);
+            }
+        }
+    };
+    // Handle going back from review
+    const handleGoBack = () => {
+        setShowReview(false);
+    };
+    // Handle advance to next question or review
+    const handleAdvanceToNext = () => {
+        if (currentQuestionIndex < sessionRequest.questions.length - 1) {
+            // Move to next question
+            setCurrentQuestionIndex((prev) => prev + 1);
+        }
+        else {
+            // Last question - show review
+            setShowReview(true);
+        }
+    };
+    // Handle session rejection
+    const handleRejectSession = async (reason) => {
+        try {
+            const sessionManager = new SessionManager();
+            await sessionManager.rejectSession(sessionId, reason);
+            // Call onComplete with rejection flag
+            if (onComplete) {
+                onComplete(true);
+            }
+        }
+        catch (error) {
+            console.error("Failed to reject session:", error);
+            setShowRejectionConfirm(false);
+        }
+    };
+    // Global keyboard shortcuts and navigation
+    useInput((input, key) => {
+        // Don't handle navigation when showing review, submitting, or confirming rejection
+        if (showReview || submitting || showRejectionConfirm)
+            return;
+        // Esc key - show rejection confirmation
+        if (key.escape) {
+            setShowRejectionConfirm(true);
+            return;
+        }
+        // Question navigation with arrow keys
+        if (key.leftArrow && currentQuestionIndex > 0) {
+            setCurrentQuestionIndex((prev) => prev - 1);
+        }
+        if (key.rightArrow &&
+            currentQuestionIndex < sessionRequest.questions.length - 1) {
+            setCurrentQuestionIndex((prev) => prev + 1);
+        }
+    });
+    const currentAnswer = answers.get(currentQuestionIndex);
+    // Show rejection confirmation
+    if (showRejectionConfirm) {
+        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+            React.createElement(ConfirmationDialog, { message: "Are you sure you want to reject this question set?", onCancel: () => setShowRejectionConfirm(false), onQuit: () => exit(), onReject: handleRejectSession })));
+    }
+    // Show submitting message
+    if (submitting) {
+        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+            React.createElement(Box, { borderColor: theme.colors.pending, borderStyle: "single", padding: 1 },
+                React.createElement(Text, { color: theme.colors.pending }, "Submitting answers..."))));
+    }
+    // Show review screen
+    if (showReview) {
+        return (React.createElement(ReviewScreen, { answers: answers, onConfirm: handleConfirm, onGoBack: handleGoBack, questions: sessionRequest.questions, sessionId: sessionId }));
+    }
+    // Show question display (default)
+    return (React.createElement(QuestionDisplay, { currentQuestion: currentQuestion, currentQuestionIndex: currentQuestionIndex, customAnswer: currentAnswer?.customText, onAdvanceToNext: handleAdvanceToNext, onChangeCustomAnswer: handleChangeCustomAnswer, onSelectOption: handleSelectOption, onToggleOption: handleToggleOption, multiSelect: currentQuestion.multiSelect, questions: sessionRequest.questions, selectedOption: currentAnswer?.selectedOption, answers: answers }));
+};

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

@@ -0,0 +1,42 @@
+import { Box, Text } from "ink";
+import React from "react";
+import { theme } from "../theme.js";
+/**
+ * TabBar component displays question titles horizontally with progress indicator
+ * Visual: ☑ Language ☐ App Type ☐ Framework (2/3)
+ * where ☑ indicates answered questions, ☐ indicates unanswered
+ * Active tab has underline, cyan text, and blue background
+ */
+export const TabBar = ({ currentIndex, questions, answers, }) => {
+    return (React.createElement(Box, { flexWrap: "wrap" },
+        React.createElement(Box, { paddingRight: 1 },
+            React.createElement(Text, { color: theme.colors.info }, "\u2190")),
+        questions.map((question, index) => {
+            const isActive = index === currentIndex;
+            // Use provided title or fallback to "Q1", "Q2", etc.
+            const title = question.title || `Q${index + 1}`;
+            // Check if question is answered
+            const answer = answers.get(index);
+            const isAnswered = answer && (answer.selectedOption || answer.customText);
+            const icon = isAnswered ? "☑" : "☐";
+            const iconColor = isAnswered
+                ? theme.components.tabBar.answered
+                : theme.components.tabBar.unanswered;
+            return (React.createElement(Box, { key: index, minWidth: 15, paddingRight: 1 },
+                React.createElement(Text, { color: iconColor },
+                    icon,
+                    " "),
+                React.createElement(Text, { bold: isActive, color: isActive
+                        ? theme.components.tabBar.selected
+                        : theme.components.tabBar.default, backgroundColor: isActive ? theme.components.tabBar.selectedBg : undefined, underline: isActive }, title)));
+        }),
+        React.createElement(Box, { paddingRight: 1 },
+            React.createElement(Text, { color: theme.colors.info }, "\u2192")),
+        React.createElement(Box, { minWidth: 10 },
+            React.createElement(Text, { color: theme.colors.info },
+                "[",
+                currentIndex + 1,
+                "/",
+                questions.length,
+                "]"))));
+};

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

@@ -0,0 +1,19 @@
+import { Box, Text } from "ink";
+import React, { useEffect } from "react";
+/**
+ * Toast component for brief non-blocking notifications
+ * Auto-dismisses after specified duration (default 2000ms)
+ */
+export const Toast = ({ message, type = "success", onDismiss, duration = 2000, }) => {
+    // Auto-dismiss after duration
+    useEffect(() => {
+        const timer = setTimeout(() => {
+            onDismiss();
+        }, duration);
+        return () => clearTimeout(timer);
+    }, [duration, onDismiss]);
+    // Color based on type
+    const color = type === "success" ? "green" : type === "error" ? "red" : "cyan";
+    return (React.createElement(Box, { borderColor: color, borderStyle: "round", paddingX: 2, paddingY: 0.5 },
+        React.createElement(Text, { bold: true, color: color }, message)));
+};

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

@@ -0,0 +1,20 @@
+import { Box, Text } from "ink";
+import React from "react";
+import { AnimatedGradient } from "./AnimatedGradient.js";
+/**
+ * WaitingScreen displays when no question sets are being processed
+ * Shows "Waiting for AI..." message or queue status
+ */
+export const WaitingScreen = ({ queueCount }) => {
+    if (queueCount === 0) {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { justifyContent: "center", paddingY: 1 },
+                React.createElement(AnimatedGradient, { text: "Waiting for AI to ask questions\u2026" })),
+            React.createElement(Box, { justifyContent: "center", paddingY: 1 },
+                React.createElement(Text, { dimColor: true }, "Press q to quit"))));
+    }
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(AnimatedGradient, { text: `Processing question set... (${queueCount} remaining in queue)` }),
+        React.createElement(Box, { justifyContent: "center", paddingY: 1 },
+            React.createElement(Text, { dimColor: true }, "Press q to quit"))));
+};

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

@@ -0,0 +1,195 @@
+/**
+ * TUI Session Watcher Module
+ *
+ * Provides TUI applications with the ability to detect new question sessions
+ * and coordinate with the MCP server through file system events.
+ */
+import { atomicReadFile } from "../session/atomic-operations.js";
+import { TUISessionWatcher } from "../session/file-watcher.js";
+import { SESSION_FILES } from "../session/types.js";
+import { getSessionDirectory } from "../session/utils.js";
+/**
+ * Enhanced TUI Session Watcher with session data loading
+ */
+export class EnhancedTUISessionWatcher extends TUISessionWatcher {
+    autoLoadData;
+    eventHandlers = new Map();
+    constructor(config) {
+        // Map sessionDir to baseDir for parent class
+        super({
+            baseDir: config?.sessionDir,
+            debounceMs: config?.debounceMs,
+        });
+        this.autoLoadData = config?.autoLoadData ?? true;
+    }
+    /**
+     * Add custom event handler
+     */
+    addEventHandler(name, handler) {
+        this.eventHandlers.set(name, handler);
+    }
+    /**
+     * Get list of pending sessions (sessions without answers and status is pending/in-progress)
+     */
+    async getPendingSessions() {
+        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 pendingSessions = [];
+            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 {
+                    // Check if answers file doesn't exist (pending session)
+                    await fs.access(answersPath);
+                }
+                catch {
+                    // Answers file doesn't exist - check status
+                    try {
+                        const statusContent = await fs.readFile(statusPath, "utf-8");
+                        const status = JSON.parse(statusContent);
+                        // Only include sessions that are actually pending or in-progress
+                        // Exclude: rejected, completed, timed_out, abandoned
+                        if (status.status === "pending" || status.status === "in-progress") {
+                            pendingSessions.push(entry.name);
+                        }
+                    }
+                    catch {
+                        // No valid status file - not a valid session
+                    }
+                }
+            }
+            return pendingSessions.sort(); // Sort for consistent ordering
+        }
+        catch (error) {
+            console.warn("Failed to scan for pending sessions:", error);
+            return [];
+        }
+    }
+    /**
+     * Get session request data for a specific session
+     */
+    async getSessionRequest(sessionId) {
+        const { join } = await import("path");
+        const sessionPath = join(this.watchedPath, sessionId);
+        try {
+            return await this.loadSessionRequest(sessionPath);
+        }
+        catch (error) {
+            console.warn(`Failed to load session request for ${sessionId}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Check if a session exists and is pending
+     */
+    async isSessionPending(sessionId) {
+        const { join } = await import("path");
+        const sessionPath = join(this.watchedPath, sessionId);
+        const answersPath = join(sessionPath, SESSION_FILES.ANSWERS);
+        const statusPath = join(sessionPath, SESSION_FILES.STATUS);
+        try {
+            const fs = await import("fs/promises");
+            // Check if status file exists (valid session)
+            await fs.access(statusPath);
+            // Check if answers file doesn't exist (pending)
+            try {
+                await fs.access(answersPath);
+                return false; // Answers exist - session is completed
+            }
+            catch {
+                return true; // No answers - session is pending
+            }
+        }
+        catch {
+            return false; // Not a valid session
+        }
+    }
+    /**
+     * Remove event handler
+     */
+    removeEventHandler(name) {
+        this.eventHandlers.delete(name);
+    }
+    /**
+     * Start watching with enhanced event handling
+     */
+    startEnhancedWatching(onSessionEvent) {
+        this.startWatching(async (sessionId, sessionPath) => {
+            const event = {
+                sessionId,
+                sessionPath,
+                timestamp: Date.now(),
+                type: "session-created",
+            };
+            // Auto-load session data if requested
+            if (this.autoLoadData) {
+                try {
+                    const sessionRequest = await this.loadSessionRequest(sessionPath);
+                    event.sessionRequest = sessionRequest;
+                }
+                catch (error) {
+                    console.warn(`Failed to load session request for ${sessionId}:`, error);
+                }
+            }
+            // Emit the event
+            onSessionEvent(event);
+            // Call any additional handlers
+            this.eventHandlers.forEach((handler) => handler(event));
+        });
+    }
+    /**
+     * Load session request data from file
+     */
+    async loadSessionRequest(sessionPath) {
+        const requestPath = `${sessionPath}/${SESSION_FILES.REQUEST}`;
+        try {
+            const content = await atomicReadFile(requestPath, {
+                encoding: "utf8",
+                maxRetries: 3,
+                retryDelay: 100,
+            });
+            return JSON.parse(content);
+        }
+        catch (error) {
+            throw new Error(`Failed to load session request from ${requestPath}: ${error}`);
+        }
+    }
+}
+/**
+ * Create a simple TUI session watcher instance
+ * Auto-detects session directory based on global vs local install
+ */
+export function createTUIWatcher(config) {
+    // Auto-detect session directory if not provided in config
+    const sessionDir = config?.sessionDir ?? getSessionDirectory();
+    return new EnhancedTUISessionWatcher({
+        ...config,
+        sessionDir,
+    });
+}
+/**
+ * Convenience function to get the next pending session
+ */
+export async function getNextPendingSession(config) {
+    const watcher = createTUIWatcher(config);
+    const pendingSessions = await watcher.getPendingSessions();
+    if (pendingSessions.length === 0) {
+        return null;
+    }
+    // Try each pending session until we find one with valid data
+    for (const sessionId of pendingSessions) {
+        const sessionRequest = await watcher.getSessionRequest(sessionId);
+        if (sessionRequest) {
+            return { sessionId, sessionRequest };
+        }
+        // Skip corrupted sessions and continue to next one
+    }
+    // No valid sessions found
+    return null;
+}

package/dist/src/tui/theme.js

@@ -0,0 +1,114 @@
+/**
+ * Centralized Theme Configuration
+ * Customize all colors and gradients in one place
+ *
+ * HOW TO CUSTOMIZE:
+ * Simply edit the color values below and rebuild with `npm run build`
+ *
+ * Available terminal colors:
+ * - Basic: "black", "red", "green", "yellow", "blue", "magenta", "cyan", "white"
+ * - Bright: "gray", "grey", "brightRed", "brightGreen", etc.
+ * - Or use hex colors: "#FF5733"
+ *
+ * HEADER GRADIENT THEMES (from gradient-string):
+ * Change 'headerGradient' below to any of these beautiful premade gradients:
+ * - "cristal"    - Crystal clear blues
+ * - "teen"       - Vibrant teen energy
+ * - "mind"       - Psychedelic colors
+ * - "morning"    - Sunrise colors
+ * - "vice"       - Neon vice city
+ * - "passion"    - Passionate reds
+ * - "fruit"      - Fruity colors
+ * - "instagram"  - Instagram gradient
+ * - "atlas"      - Atlas blue
+ * - "retro"      - Retro gaming
+ * - "summer"     - Summer vibes
+ * - "pastel"     - Soft pastels
+ * - "rainbow"    - Full rainbow
+ */
+export const theme = {
+    /**
+     * Header Gradient Theme
+     * To change: Replace "pastel" with any gradient name from the list above
+     */
+    headerGradient: "vice",
+    /**
+     * Gradient Colors (deprecated - use headerGradient instead)
+     * Used for logo, welcome messages, and decorative text
+     */
+    gradient: {
+        start: "cyan",
+        middle: "green",
+        end: "yellow",
+    },
+    /**
+     * UI State Colors
+     */
+    colors: {
+        // Primary UI colors
+        primary: "cyan",
+        success: "green",
+        warning: "yellow",
+        error: "red",
+        info: "blue",
+        // Interactive states
+        focused: "cyan",
+        selected: "green",
+        pending: "yellow",
+        // Text colors
+        text: "white",
+        textDim: "gray",
+        textBold: "white",
+    },
+    /**
+     * Border Colors
+     */
+    borders: {
+        primary: "cyan",
+        warning: "yellow",
+        error: "red",
+        neutral: "gray",
+    },
+    /**
+     * Component-Specific Colors
+     */
+    components: {
+        header: {
+            border: "cyan",
+            queueActive: "yellow",
+            queueEmpty: "green",
+            queueFlash: "cyan",
+        },
+        tabBar: {
+            selected: "cyan",
+            selectedBg: "black",
+            default: "white",
+            answered: "green",
+            unanswered: "gray",
+        },
+        options: {
+            focused: "cyan",
+            selected: "green",
+            default: "white",
+        },
+        review: {
+            border: "cyan",
+            confirmBorder: "yellow",
+            selectedOption: "green",
+            customAnswer: "yellow",
+        },
+        toast: {
+            success: "green",
+            error: "red",
+            info: "cyan",
+        },
+    },
+};
+/**
+ * Export gradient colors as array for gradient-string
+ */
+export const gradientColors = [
+    theme.gradient.start,
+    theme.gradient.middle,
+    theme.gradient.end,
+];

package/dist/src/tui/utils/gradientText.js

@@ -0,0 +1,24 @@
+import gradient from "gradient-string";
+import { gradientColors } from "../theme.js";
+/**
+ * Theme-based gradient for decorative text in the TUI.
+ * Colors are defined in theme.ts and can be customized in one place.
+ */
+export const themeGradient = gradient(gradientColors);
+/**
+ * Apply theme gradient to welcome/decorative text.
+ * Returns ANSI-colored string compatible with Ink <Text> components.
+ */
+export function welcomeText(text) {
+    return themeGradient(text);
+}
+/**
+ * Apply theme gradient to goodbye/decorative text.
+ * Returns ANSI-colored string compatible with Ink <Text> components.
+ */
+export function goodbyeText(text) {
+    return themeGradient(text);
+}
+export function gradientText(text) {
+    return themeGradient(text);
+}