auq-mcp-server 0.1.10 → 1.2.5

package/dist/src/shared/schemas.js

@@ -0,0 +1,64 @@
+import { z } from "zod";
+export const OptionSchema = z.object({
+    label: z
+        .string()
+        .describe("The display text for this option that the user will see and select. " +
+        "Should be concise (1-5 words) and clearly describe the choice."),
+    description: z
+        .string()
+        .optional()
+        .describe("Explanation of what this option means or what will happen if chosen. " +
+        "Useful for providing context about trade-offs or implications."),
+});
+export const QuestionSchema = z.object({
+    prompt: z
+        .string()
+        .describe("The complete question to ask the user. Should be clear, specific, and end with a question mark. " +
+        "Example: 'Which programming language do you want to use?' " +
+        "If multiSelect is true, phrase it accordingly, e.g. 'Which features do you want to enable?'"),
+    title: z
+        .string()
+        .min(1, "Question title is required. Provide a short summary like 'Language' or 'Framework'.")
+        .describe("Very short label displayed as a chip/tag (max 12 chars). " +
+        "Examples: 'Auth method', 'Library', 'Approach'. " +
+        "This title appears in the interface to help users quickly identify questions."),
+    options: z
+        .array(OptionSchema)
+        .min(2)
+        .max(4)
+        .describe("The available choices for this question. Must have 2-4 options. " +
+        "Each option should be a distinct, mutually exclusive choice (unless multiSelect is enabled). " +
+        "There should be no 'Other' option, that will be provided automatically."),
+    multiSelect: z
+        .boolean()
+        .describe("Set to true to allow the user to select multiple options instead of just one. " +
+        "Use when choices are not mutually exclusive. Default: false (single-select)"),
+});
+export const QuestionsSchema = z.array(QuestionSchema).min(1).max(4);
+export const AskUserQuestionsParametersSchema = z.object({
+    questions: QuestionsSchema.describe("Questions to ask the user (1-4 questions). " +
+        "Each question must include: prompt (full question text), title (short label, max 12 chars), " +
+        "options (2-4 choices with labels and descriptions), and multiSelect (boolean). " +
+        "Mark one choice as recommended if possible."),
+});
+export const TOOL_DESCRIPTION = "Use this tool when you need to ask the user questions during execution. " +
+    "This allows you to:\n" +
+    "1. Gather user preferences or requirements\n" +
+    "2. Clarify ambiguous instructions\n" +
+    "3. Get decisions on implementation choices as you work\n" +
+    "4. Offer choices to the user about what direction to take\n\n" +
+    "FEATURES:\n" +
+    "- Ask 1-4 structured questions via an interactive terminal interface\n" +
+    "- Each question includes 2-4 multiple-choice options with explanatory descriptions\n" +
+    "- Users can always provide custom free-text input as an alternative to predefined options\n" +
+    "- Single-select mode (default): User picks ONE option or provides custom text\n" +
+    "- Multi-select mode (multiSelect: true): User can select MULTIPLE options\n\n" +
+    "USAGE NOTES:\n" +
+    "- Always provide a descriptive 'title' field (max 12 chars) for each question\n" +
+    "- Use multiSelect: true when choices are not mutually exclusive\n" +
+    "- Option labels should be concise (1-5 words)\n" +
+    "- Questions should end with a question mark\n" +
+    "- Don't include an 'Other' option - it's provided automatically\n" +
+    "- Mark one choice as recommended if possible.\n\n" +
+    "- If user seems not aware how to answer the question, inform them that they need to install the 'auq' cli tool.\n\n" +
+    "Returns a formatted summary of all questions and answers.";

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

@@ -2,6 +2,7 @@ import { Box, Text } from "ink";
 import gradient from "gradient-string";
 import React, { useEffect, useState } from "react";
 import { theme } from "../theme.js";
+import packageJson from "../../../package.json" with { type: "json" };
 /**
  * Header component - displays app logo and status
  * Shows at the top of the TUI with gradient branding and live-updating pending queue count
@@ -18,12 +19,19 @@ export const Header = ({ pendingCount }) => {
             return () => clearTimeout(timer);
         }
     }, [pendingCount, prevCount]);
+    // Get version from package.json
+    const version = React.useMemo(() => {
+        return packageJson.version || "unknown";
+    }, []);
     // Use the selected gradient theme from theme.ts
     const headerText = gradient[theme.headerGradient](".𖥔 AUQ ⋆ Ask User Questions MCP ⋆ ");
     return (React.createElement(Box, { borderColor: theme.components.header.border, borderStyle: "single", flexDirection: "row", justifyContent: "space-between", paddingX: 1 },
         React.createElement(Text, { bold: true }, headerText),
         React.createElement(Box, null,
-            React.createElement(Text, { dimColor: true }, "\u2502"),
+            React.createElement(Text, { dimColor: true },
+                "v",
+                version,
+                " \u2502"),
             React.createElement(Text, { bold: flash, color: flash
                     ? theme.components.header.queueFlash
                     : pendingCount > 0

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

@@ -1,12 +1,19 @@
 import { Box, Text, useInput } from "ink";
-import React from "react";
+import React, { useState } from "react";
 import { theme } from "../theme.js";
 /**
- * Multi-line text input component for Ink
- * Append-only mode: Shift+Enter for newlines, Enter to submit
- * Note: No cursor positioning - text is append-only for simplicity
+ * Multi-line text input component for Ink with cursor positioning
+ * Supports left/right arrow keys for cursor movement
+ * Shift+Enter for newlines, Enter to submit
  */
 export const MultiLineTextInput = ({ isFocused = true, onChange, onSubmit, placeholder = "Type your answer...", value, }) => {
+    const [cursorPosition, setCursorPosition] = useState(value.length);
+    // Update cursor position when value changes externally
+    React.useEffect(() => {
+        if (cursorPosition > value.length) {
+            setCursorPosition(value.length);
+        }
+    }, [value.length, cursorPosition]);
     useInput((input, key) => {
         if (!isFocused)
             return;
@@ -14,7 +21,9 @@ export const MultiLineTextInput = ({ isFocused = true, onChange, onSubmit, place
         // Prevent accidental carriage return insertion which causes line overwrite in terminals.
         if (input === "\r" || input === "\n") {
             if (key.shift) {
-                onChange(value + "\n");
+                const newValue = value.slice(0, cursorPosition) + "\n" + value.slice(cursorPosition);
+                onChange(newValue);
+                setCursorPosition(cursorPosition + 1);
             }
             else if (onSubmit) {
                 onSubmit();
@@ -23,7 +32,9 @@ export const MultiLineTextInput = ({ isFocused = true, onChange, onSubmit, place
         }
         // Shift+Enter: Add newline
         if (key.return && key.shift) {
-            onChange(value + "\n");
+            const newValue = value.slice(0, cursorPosition) + "\n" + value.slice(cursorPosition);
+            onChange(newValue);
+            setCursorPosition(cursorPosition + 1);
             return;
         }
         // Enter: Submit (empty input allowed)
@@ -33,33 +44,61 @@ export const MultiLineTextInput = ({ isFocused = true, onChange, onSubmit, place
             }
             return;
         }
-        // Backspace: Remove last character
+        // Left arrow: Move cursor left
+        if (key.leftArrow) {
+            setCursorPosition(Math.max(0, cursorPosition - 1));
+            return;
+        }
+        // Right arrow: Move cursor right
+        if (key.rightArrow) {
+            setCursorPosition(Math.min(value.length, cursorPosition + 1));
+            return;
+        }
+        // Backspace: Remove character before cursor
         if (key.backspace || key.delete) {
-            onChange(value.slice(0, -1));
+            if (cursorPosition > 0) {
+                const newValue = value.slice(0, cursorPosition - 1) + value.slice(cursorPosition);
+                onChange(newValue);
+                setCursorPosition(cursorPosition - 1);
+            }
             return;
         }
-        // Regular character input (append)
+        // Regular character input (insert at cursor)
         if (input &&
             !key.ctrl &&
             !key.meta &&
             !key.escape &&
             input !== "\r" &&
             input !== "\n") {
-            onChange(value + input);
+            const newValue = value.slice(0, cursorPosition) + input + value.slice(cursorPosition);
+            onChange(newValue);
+            setCursorPosition(cursorPosition + 1);
         }
     }, { isActive: isFocused });
     // Normalize any carriage returns that might already be present in value
     const normalizedValue = value.replace(/\r\n?/g, "\n");
     const hasContent = normalizedValue.length > 0;
     const lines = hasContent ? normalizedValue.split("\n") : [placeholder];
+    // Calculate which line and position the cursor is on
+    const cursorLineIndex = normalizedValue.slice(0, cursorPosition).split("\n").length - 1;
+    const cursorLineStart = normalizedValue.split("\n").slice(0, cursorLineIndex).join("\n").length + (cursorLineIndex > 0 ? cursorLineIndex : 0);
+    const cursorPositionInLine = cursorPosition - cursorLineStart;
     return (React.createElement(Box, { flexDirection: "column" }, lines.map((line, index) => {
-        const isLastLine = index === lines.length - 1;
-        const showCursor = isFocused && isLastLine;
+        const isCursorLine = isFocused && index === cursorLineIndex && hasContent;
         const isPlaceholder = !hasContent;
         const lineHasContent = line.length > 0;
-        const displayText = lineHasContent ? line : showCursor ? "" : " ";
+        const displayText = lineHasContent ? line : isCursorLine ? "" : " ";
+        if (isCursorLine) {
+            // Split the line at cursor position
+            const beforeCursor = line.slice(0, cursorPositionInLine);
+            const afterCursor = line.slice(cursorPositionInLine);
+            return (React.createElement(Text, { key: index },
+                beforeCursor,
+                React.createElement(Text, { color: theme.colors.focused, dimColor: true }, "\u258C"),
+                afterCursor));
+        }
         return (React.createElement(Text, { key: index, dimColor: isPlaceholder },
             displayText,
-            showCursor && (React.createElement(Text, { color: theme.colors.focused, dimColor: true }, "\u258C"))));
+            isFocused && index === lines.length - 1 && !hasContent && (React.createElement(Text, { color: theme.colors.focused, dimColor: true }, "\u258C"))));
     })));
 };

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

@@ -22,6 +22,14 @@ export const OptionsList = ({ isFocused, onSelect, options, selectedOption, show
     useInput((input, key) => {
         if (!isFocused)
             return;
+        // When custom input is focused, only handle escape to exit, let MultiLineTextInput handle other keys
+        if (isCustomInputFocused) {
+            if (key.escape) {
+                // Escape: Exit custom input mode and go back to option navigation
+                setFocusedIndex(options.length - 1); // Focus on last option
+            }
+            return;
+        }
         if (key.upArrow) {
             setFocusedIndex((prev) => Math.max(0, prev - 1));
         }

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

@@ -7,7 +7,7 @@ import { TabBar } from "./TabBar.js";
  * QuestionDisplay shows a single question with its options
  * Includes TabBar, question prompt, options list, and footer
  */
-export const QuestionDisplay = ({ currentQuestion, currentQuestionIndex, customAnswer = "", onChangeCustomAnswer, onSelectOption, questions, selectedOption, onAdvanceToNext, answers, onToggleOption, multiSelect, }) => {
+export const QuestionDisplay = ({ currentQuestion, currentQuestionIndex, customAnswer = "", elapsedLabel, onChangeCustomAnswer, onSelectOption, questions, selectedOption, onAdvanceToNext, answers, onToggleOption, multiSelect, }) => {
     // Track focus context for Footer component
     const [focusContext, setFocusContext] = useState("option");
     // Handle option selection - clears custom answer only in single-select mode
@@ -26,11 +26,15 @@ export const QuestionDisplay = ({ currentQuestion, currentQuestionIndex, customA
     };
     return (React.createElement(Box, { flexDirection: "column" },
         React.createElement(TabBar, { currentIndex: currentQuestionIndex, questions: questions, answers: answers }),
-        React.createElement(Box, { marginTop: 1 },
-            React.createElement(Text, { bold: true },
-                currentQuestion.prompt,
-                " "),
-            React.createElement(Text, { dimColor: true }, multiSelect ? "[Multiple Choice]" : "[Single Choice]")),
+        React.createElement(Box, { flexDirection: "row", justifyContent: "space-between", marginTop: 1 },
+            React.createElement(Box, null,
+                React.createElement(Text, { bold: true },
+                    currentQuestion.prompt,
+                    " "),
+                React.createElement(Text, { dimColor: true }, multiSelect ? "[Multiple Choice]" : "[Single Choice]")),
+            React.createElement(Text, { dimColor: true },
+                "Elapsed ",
+                elapsedLabel)),
         React.createElement(OptionsList, { customValue: customAnswer, isFocused: true, onAdvance: onAdvanceToNext, onCustomChange: handleCustomAnswerChange, onSelect: handleSelectOption, options: currentQuestion.options, selectedOption: selectedOption, showCustomInput: true, onToggle: onToggleOption, multiSelect: multiSelect, selectedOptions: answers.get(currentQuestionIndex)?.selectedOptions, onFocusContextChange: setFocusContext }),
         React.createElement(Footer, { focusContext: focusContext, multiSelect: multiSelect ?? false, customInputValue: customAnswer })));
 };

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

@@ -6,7 +6,7 @@ import { Footer } from "./Footer.js";
  * ReviewScreen displays a summary of all answers for confirmation
  * User can press Enter to confirm and submit, or 'n' to go back and edit
  */
-export const ReviewScreen = ({ answers, onConfirm, onGoBack, questions, }) => {
+export const ReviewScreen = ({ answers, elapsedLabel, onConfirm, onGoBack, questions, }) => {
     useInput((input, key) => {
         if (key.return) {
             // Convert answers to UserAnswer format
@@ -32,7 +32,11 @@ export const ReviewScreen = ({ answers, onConfirm, onGoBack, questions, }) => {
     });
     return (React.createElement(Box, { flexDirection: "column" },
         React.createElement(Box, { borderColor: theme.components.review.border, borderStyle: "single", marginBottom: 1, padding: 0.5 },
-            React.createElement(Text, { bold: true, color: theme.components.review.border }, "Review Your Answers")),
+            React.createElement(Box, { flexDirection: "row", justifyContent: "space-between", width: "100%" },
+                React.createElement(Text, { bold: true, color: theme.components.review.border }, "Review Your Answers"),
+                React.createElement(Text, { dimColor: true },
+                    "Elapsed ",
+                    elapsedLabel))),
         React.createElement(Box, { flexDirection: "column", marginBottom: 1 }, questions.map((question, index) => {
             const answer = answers.get(index);
             const questionTitle = question.title || `Q${index + 1}`;

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

@@ -1,5 +1,5 @@
 import { Box, Text, useApp, useInput } from "ink";
-import React, { useEffect, useRef, useState } from "react";
+import React, { useEffect, useMemo, useRef, useState } from "react";
 import { SessionManager } from "../../session/SessionManager.js";
 import { getSessionDirectory } from "../../session/utils.js";
 import { theme } from "../theme.js";
@@ -17,7 +17,20 @@ export const StepperView = ({ onComplete, sessionId, sessionRequest, }) => {
     const [showReview, setShowReview] = useState(false);
     const [submitting, setSubmitting] = useState(false);
     const [showRejectionConfirm, setShowRejectionConfirm] = useState(false);
+    const [elapsedSeconds, setElapsedSeconds] = useState(0);
     const currentQuestion = sessionRequest.questions[currentQuestionIndex];
+    const sessionCreatedAt = useMemo(() => {
+        const parsed = Date.parse(sessionRequest.timestamp);
+        return Number.isNaN(parsed) ? Date.now() : parsed;
+    }, [sessionRequest.timestamp]);
+    const elapsedLabel = useMemo(() => {
+        const hours = Math.floor(elapsedSeconds / 3600);
+        const minutes = Math.floor((elapsedSeconds % 3600) / 60);
+        const seconds = elapsedSeconds % 60;
+        return [hours, minutes, seconds]
+            .map((value) => value.toString().padStart(2, "0"))
+            .join(":");
+    }, [elapsedSeconds]);
     // Handle option selection
     const handleSelectOption = (label) => {
         setAnswers((prev) => {
@@ -73,7 +86,16 @@ export const StepperView = ({ onComplete, sessionId, sessionRequest, }) => {
         setShowReview(false);
         setSubmitting(false);
         setShowRejectionConfirm(false);
+        setElapsedSeconds(0);
     }, [sessionId]);
+    // Update elapsed time since session creation
+    useEffect(() => {
+        const timer = setInterval(() => {
+            const elapsed = Math.floor((Date.now() - sessionCreatedAt) / 1000);
+            setElapsedSeconds(elapsed >= 0 ? elapsed : 0);
+        }, 1000);
+        return () => clearInterval(timer);
+    }, [sessionCreatedAt]);
     // Handle answer confirmation
     const handleConfirm = async (userAnswers) => {
         setSubmitting(true);
@@ -164,8 +186,8 @@ export const StepperView = ({ onComplete, sessionId, sessionRequest, }) => {
     }
     // Show review screen
     if (showReview) {
-        return (React.createElement(ReviewScreen, { answers: answers, onConfirm: handleConfirm, onGoBack: handleGoBack, questions: sessionRequest.questions, sessionId: sessionId }));
+        return (React.createElement(ReviewScreen, { answers: answers, elapsedLabel: elapsedLabel, 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 }));
+    return (React.createElement(QuestionDisplay, { currentQuestion: currentQuestion, currentQuestionIndex: currentQuestionIndex, customAnswer: currentAnswer?.customText, elapsedLabel: elapsedLabel, onAdvanceToNext: handleAdvanceToNext, onChangeCustomAnswer: handleChangeCustomAnswer, onSelectOption: handleSelectOption, onToggleOption: handleToggleOption, multiSelect: currentQuestion.multiSelect, questions: sessionRequest.questions, selectedOption: currentAnswer?.selectedOption, answers: answers }));
 };

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

@@ -1,20 +1,47 @@
-import { Box, Text } from "ink";
-import React from "react";
+import { Box, Text, useInput } from "ink";
+import React, { useEffect, useState } 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 }) => {
+    const [startTime] = useState(new Date());
+    const [elapsedSeconds, setElapsedSeconds] = useState(0);
+    // Update elapsed time every second
+    useEffect(() => {
+        const timer = setInterval(() => {
+            const now = new Date();
+            const elapsed = Math.floor((now.getTime() - startTime.getTime()) / 1000);
+            setElapsedSeconds(elapsed);
+        }, 1000);
+        return () => clearInterval(timer);
+    }, [startTime]);
+    // Handle 'q' key to quit
+    useInput((input, key) => {
+        if (input === 'q') {
+            process.exit(0);
+        }
+    });
     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"))));
+                React.createElement(Text, { dimColor: true }, "Press Ctrl+C to quit")),
+            React.createElement(Box, { justifyContent: "center", paddingY: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "Time elapsed: ",
+                    elapsedSeconds,
+                    "s"))));
     }
     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"))));
+            React.createElement(Text, { dimColor: true }, "Press Ctrl+C to quit")),
+        React.createElement(Box, { justifyContent: "center", paddingY: 1 },
+            React.createElement(Text, { dimColor: true },
+                "Time elapsed: ",
+                elapsedSeconds,
+                "s"))));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auq-mcp-server",
-  "version": "0.1.10",
+  "version": "1.2.5",
   "main": "dist/index.js",
   "bin": {
     "auq": "dist/bin/auq.js"
@@ -11,14 +11,19 @@
     "README.md",
     "LICENSE"
   ],
+  "workspaces": [
+    "packages/opencode-plugin"
+  ],
   "scripts": {
-    "build": "tsc",
+    "build": "npm run sync-schemas && tsc",
     "prepare": "npm run build",
     "postinstall": "node scripts/postinstall.cjs",
+    "deploy": "node scripts/deploy.mjs",
     "server": "node dist/src/server.js",
     "start": "tsx src/server.ts",
     "dev": "fastmcp dev src/server.ts",
     "lint": "prettier --check . && eslint . && tsc --noEmit",
+    "sync-schemas": "node scripts/sync-schemas.mjs",
     "test": "vitest run",
     "format": "prettier --write . && eslint --fix ."
   },
@@ -39,6 +44,7 @@
   "description": "An MCP server that provides a tool to ask a user questions via the terminal",
   "dependencies": {
     "@inkjs/ui": "^2.0.0",
+    "@modelcontextprotocol/sdk": "1.17.2",
     "@types/uuid": "^10.0.0",
     "chalk": "^5.6.2",
     "fastmcp": "^3.23.0",
@@ -48,8 +54,7 @@
     "ink-text-input": "^6.0.0",
     "react": "^19.2.0",
     "uuid": "^13.0.0",
-    "zod": "^4.1.13",
-    "@modelcontextprotocol/sdk": "1.17.2"
+    "zod": "^4.1.13"
   },
   "release": {
     "branches": [
@@ -65,6 +70,7 @@
   "devDependencies": {
     "@eslint/js": "^9.26.0",
     "@tsconfig/node22": "^22.0.1",
+    "@types/node": "^22.13.0",
     "@types/react": "^19.2.2",
     "eslint-config-prettier": "^10.1.3",
     "eslint-plugin-perfectionist": "^4.12.3",

package/dist/__tests__/schema-validation.test.js

@@ -1,137 +0,0 @@
-/**
- * Minimal schema validation tests for Question/Option types
- * Tests the most common edge cases to catch obvious bugs
- */
-import { describe, expect, it } from "vitest";
-import { z } from "zod";
-// Import schemas from server (in real implementation, might extract to validation module)
-const OptionSchema = z.object({
-    description: z.string().optional(),
-    label: z.string(),
-});
-const QuestionSchema = z.object({
-    title: z.string(),
-    options: z.array(OptionSchema).min(1),
-    prompt: z.string(),
-});
-const QuestionsArraySchema = z.array(QuestionSchema).min(1);
-describe("Schema Validation - Edge Cases", () => {
-    describe("Invalid Input (should reject)", () => {
-        it("should reject missing title field", () => {
-            const invalidQuestion = {
-                // title missing
-                options: [{ label: "Option 1" }],
-                prompt: "Test question?",
-            };
-            expect(() => QuestionSchema.parse(invalidQuestion)).toThrow();
-        });
-        it("should reject empty options array", () => {
-            const invalidQuestion = {
-                title: "Test",
-                options: [], // Empty array
-                prompt: "Test question?",
-            };
-            expect(() => QuestionSchema.parse(invalidQuestion)).toThrow();
-        });
-        it("should reject missing prompt", () => {
-            const invalidQuestion = {
-                title: "Test",
-                options: [{ label: "Option 1" }],
-                // prompt missing
-            };
-            expect(() => QuestionSchema.parse(invalidQuestion)).toThrow();
-        });
-        it("should reject missing options field", () => {
-            const invalidQuestion = {
-                title: "Test",
-                // options missing
-                prompt: "Test question?",
-            };
-            expect(() => QuestionSchema.parse(invalidQuestion)).toThrow();
-        });
-        it("should reject option with missing label", () => {
-            const invalidQuestion = {
-                title: "Test",
-                options: [
-                    {
-                        description: "A description",
-                        // label missing
-                    },
-                ],
-                prompt: "Test question?",
-            };
-            expect(() => QuestionSchema.parse(invalidQuestion)).toThrow();
-        });
-        it("should reject empty questions array", () => {
-            const invalidQuestions = [];
-            expect(() => QuestionsArraySchema.parse(invalidQuestions)).toThrow();
-        });
-    });
-    describe("Valid Input (should accept)", () => {
-        it("should accept valid question with title", () => {
-            const validQuestion = {
-                title: "Language",
-                options: [
-                    {
-                        description: "A helpful description",
-                        label: "Option 1",
-                    },
-                ],
-                prompt: "What is your choice?",
-            };
-            expect(() => QuestionSchema.parse(validQuestion)).not.toThrow();
-            const parsed = QuestionSchema.parse(validQuestion);
-            expect(parsed.title).toBe("Language");
-            expect(parsed.prompt).toBe("What is your choice?");
-            expect(parsed.options).toHaveLength(1);
-        });
-        it("should accept valid question with all fields", () => {
-            const validQuestion = {
-                title: "Framework",
-                options: [
-                    {
-                        description: "A helpful description",
-                        label: "Option 1",
-                    },
-                ],
-                prompt: "What is your choice?",
-            };
-            expect(() => QuestionSchema.parse(validQuestion)).not.toThrow();
-            const parsed = QuestionSchema.parse(validQuestion);
-            expect(parsed.prompt).toBe("What is your choice?");
-            expect(parsed.options).toHaveLength(1);
-        });
-        it("should accept valid question with description omitted", () => {
-            const validQuestion = {
-                title: "Choice",
-                options: [
-                    {
-                        label: "Option 1",
-                        // description omitted (optional)
-                    },
-                ],
-                prompt: "What is your choice?",
-            };
-            expect(() => QuestionSchema.parse(validQuestion)).not.toThrow();
-            const parsed = QuestionSchema.parse(validQuestion);
-            expect(parsed.options[0].description).toBeUndefined();
-        });
-        it("should accept multiple valid questions", () => {
-            const validQuestions = [
-                {
-                    title: "First",
-                    options: [{ label: "A" }],
-                    prompt: "Question 1?",
-                },
-                {
-                    title: "Second",
-                    options: [{ label: "B" }, { label: "C" }],
-                    prompt: "Question 2?",
-                },
-            ];
-            expect(() => QuestionsArraySchema.parse(validQuestions)).not.toThrow();
-            const parsed = QuestionsArraySchema.parse(validQuestions);
-            expect(parsed).toHaveLength(2);
-        });
-    });
-});