@vfarcic/dot-ai 0.1.0

package/dist/tools/answer-question.js

@@ -0,0 +1,696 @@
+"use strict";
+/**
+ * Answer Question Tool - Process user answers and return remaining questions
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANSWERQUESTION_TOOL_INPUT_SCHEMA = exports.ANSWERQUESTION_TOOL_DESCRIPTION = exports.ANSWERQUESTION_TOOL_NAME = void 0;
+exports.handleAnswerQuestionTool = handleAnswerQuestionTool;
+const zod_1 = require("zod");
+const error_handling_1 = require("../core/error-handling");
+const claude_1 = require("../core/claude");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const session_utils_1 = require("../core/session-utils");
+// Tool metadata for direct MCP registration
+exports.ANSWERQUESTION_TOOL_NAME = 'answerQuestion';
+exports.ANSWERQUESTION_TOOL_DESCRIPTION = 'Process user answers and return remaining questions or completion status';
+// Zod schema for MCP registration
+exports.ANSWERQUESTION_TOOL_INPUT_SCHEMA = {
+    solutionId: zod_1.z.string().regex(/^sol_[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{6}_[a-f0-9]+$/).describe('The solution ID to update (e.g., sol_2025-07-01T154349_1e1e242592ff)'),
+    stage: zod_1.z.enum(['required', 'basic', 'advanced', 'open']).describe('The configuration stage being addressed'),
+    answers: zod_1.z.record(zod_1.z.any()).describe('User answers to configuration questions for the specified stage')
+};
+/**
+ * Load solution file by ID
+ */
+function loadSolutionFile(solutionId, sessionDir) {
+    const solutionPath = path.join(sessionDir, `${solutionId}.json`);
+    if (!fs.existsSync(solutionPath)) {
+        throw new Error(`Solution file not found: ${solutionPath}. Available files: ${fs.readdirSync(sessionDir).filter(f => f.endsWith('.json')).join(', ')}`);
+    }
+    try {
+        const content = fs.readFileSync(solutionPath, 'utf8');
+        const solution = JSON.parse(content);
+        // Validate solution structure
+        if (!solution.solutionId || !solution.questions) {
+            throw new Error(`Invalid solution file structure: ${solutionId}. Missing required fields: solutionId or questions`);
+        }
+        return solution;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error(`Invalid JSON in solution file: ${solutionId}`);
+        }
+        throw error;
+    }
+}
+/**
+ * Save solution file with atomic operations
+ */
+function saveSolutionFile(solution, solutionId, sessionDir) {
+    const solutionPath = path.join(sessionDir, `${solutionId}.json`);
+    const tempPath = solutionPath + '.tmp';
+    try {
+        // Write to temporary file first
+        fs.writeFileSync(tempPath, JSON.stringify(solution, null, 2), 'utf8');
+        // Atomically rename to final path
+        fs.renameSync(tempPath, solutionPath);
+    }
+    catch (error) {
+        // Clean up temporary file if it exists
+        if (fs.existsSync(tempPath)) {
+            try {
+                fs.unlinkSync(tempPath);
+            }
+            catch (cleanupError) {
+                // Ignore cleanup errors
+            }
+        }
+        throw error;
+    }
+}
+/**
+ * Validate answer against question schema
+ */
+function validateAnswer(answer, question) {
+    // Check required validation
+    if (question.validation?.required && (answer === undefined || answer === null || answer === '')) {
+        return question.validation.message || `${question.question} is required`;
+    }
+    // Skip validation if answer is empty and not required
+    if (answer === undefined || answer === null || answer === '') {
+        return null;
+    }
+    // Type validation
+    switch (question.type) {
+        case 'number': {
+            if (typeof answer !== 'number' && !(!isNaN(Number(answer)))) {
+                return `${question.question} must be a number`;
+            }
+            const numValue = typeof answer === 'number' ? answer : Number(answer);
+            if (question.validation?.min !== undefined && numValue < question.validation.min) {
+                return `${question.question} must be at least ${question.validation.min}`;
+            }
+            if (question.validation?.max !== undefined && numValue > question.validation.max) {
+                return `${question.question} must be at most ${question.validation.max}`;
+            }
+            break;
+        }
+        case 'text':
+            if (typeof answer !== 'string') {
+                return `${question.question} must be a string`;
+            }
+            if (question.validation?.pattern) {
+                const pattern = new RegExp(question.validation.pattern);
+                if (!pattern.test(answer)) {
+                    return question.validation.message || `${question.question} format is invalid`;
+                }
+            }
+            break;
+        case 'boolean':
+            if (typeof answer !== 'boolean') {
+                return `${question.question} must be true or false`;
+            }
+            break;
+        case 'select':
+            if (question.options && !question.options.includes(answer)) {
+                return `${question.question} must be one of: ${question.options.join(', ')}`;
+            }
+            break;
+    }
+    return null;
+}
+/**
+ * Get anti-cascade agent instructions for stage responses
+ */
+function getAgentInstructions(stage) {
+    switch (stage) {
+        case 'required':
+            return 'CRITICAL: Present these required questions to the user. All must be answered before proceeding.';
+        case 'basic':
+            return 'CRITICAL: Present these questions to the user and wait for their response. Do NOT skip this stage unless the user explicitly says to skip THIS specific stage.';
+        case 'advanced':
+            return 'CRITICAL: Present these questions to the user and wait for their response. Do NOT skip this stage unless the user explicitly says to skip THIS specific stage.';
+        case 'open':
+            return 'CRITICAL: This is the final configuration stage. Present these questions to the user. Use "N/A" only if user explicitly states no additional requirements.';
+        default:
+            return 'Present questions to the user and wait for their response.';
+    }
+}
+/**
+ * Determine current stage based on solution state
+ */
+function getCurrentStage(solution) {
+    const hasRequired = solution.questions.required && solution.questions.required.length > 0;
+    const hasBasic = solution.questions.basic && solution.questions.basic.length > 0;
+    const hasAdvanced = solution.questions.advanced && solution.questions.advanced.length > 0;
+    const hasOpen = !!solution.questions.open;
+    // Check completion status
+    const requiredComplete = !hasRequired || solution.questions.required.every((q) => q.answer !== undefined);
+    const basicComplete = !hasBasic || solution.questions.basic.every((q) => q.answer !== undefined);
+    const advancedComplete = !hasAdvanced || solution.questions.advanced.every((q) => q.answer !== undefined);
+    const openComplete = !hasOpen || solution.questions.open.answer !== undefined;
+    // Determine current stage
+    if (!requiredComplete) {
+        return {
+            currentStage: 'required',
+            nextStage: hasBasic ? 'basic' : 'open',
+            hasQuestions: true,
+            isComplete: false
+        };
+    }
+    if (!basicComplete) {
+        return {
+            currentStage: 'basic',
+            nextStage: hasAdvanced ? 'advanced' : 'open',
+            hasQuestions: true,
+            isComplete: false
+        };
+    }
+    if (!advancedComplete) {
+        return {
+            currentStage: 'advanced',
+            nextStage: 'open',
+            hasQuestions: true,
+            isComplete: false
+        };
+    }
+    if (!openComplete) {
+        return {
+            currentStage: 'open',
+            nextStage: null,
+            hasQuestions: hasOpen,
+            isComplete: false
+        };
+    }
+    // All stages complete
+    return {
+        currentStage: 'open',
+        nextStage: null,
+        hasQuestions: false,
+        isComplete: true
+    };
+}
+/**
+ * Validate stage transition is allowed
+ */
+function validateStageTransition(currentStage, requestedStage) {
+    const validTransitions = {
+        'required': ['basic', 'open'],
+        'basic': ['advanced', 'open'],
+        'advanced': ['open'],
+        'open': []
+    };
+    if (currentStage === requestedStage) {
+        return { valid: true }; // Same stage is always valid
+    }
+    const allowedNext = validTransitions[currentStage] || [];
+    if (!allowedNext.includes(requestedStage)) {
+        return {
+            valid: false,
+            error: `Cannot transition from '${currentStage}' to '${requestedStage}'. Valid options: ${allowedNext.join(', ')}`
+        };
+    }
+    return { valid: true };
+}
+/**
+ * Get questions for a specific stage
+ */
+function getQuestionsForStage(solution, stage) {
+    switch (stage) {
+        case 'required':
+            return solution.questions.required || [];
+        case 'basic':
+            return solution.questions.basic || [];
+        case 'advanced':
+            return solution.questions.advanced || [];
+        case 'open':
+            return solution.questions.open ? [solution.questions.open] : [];
+        default:
+            return [];
+    }
+}
+/**
+ * Get stage-specific message
+ */
+function getStageMessage(stage) {
+    switch (stage) {
+        case 'required':
+            return 'Please answer the required configuration questions.';
+        case 'basic':
+            return 'Would you like to configure basic settings?';
+        case 'advanced':
+            return 'Would you like to configure advanced features?';
+        case 'open':
+            return 'Any additional requirements or constraints?';
+        default:
+            return 'Configuration stage unknown.';
+    }
+}
+/**
+ * Get stage-specific guidance
+ */
+function getStageGuidance(stage) {
+    switch (stage) {
+        case 'required':
+            return 'All required questions must be answered to proceed.';
+        case 'basic':
+            return 'Answer questions in this stage or skip to proceed to the advanced stage. Do NOT try to generate manifests yet.';
+        case 'advanced':
+            return 'Answer questions in this stage or skip to proceed to the open stage. Do NOT try to generate manifests yet.';
+        case 'open':
+            return 'Use "N/A" if you have no additional requirements. Complete this stage before generating manifests. IMPORTANT: This is the final configuration stage - do not skip.';
+        default:
+            return 'Please provide answers for this stage.';
+    }
+}
+/**
+ * Phase 1: Analyze what resources are needed for the user request
+ */
+async function analyzeResourceNeeds(currentSolution, openResponse, context) {
+    const promptPath = path.join(process.cwd(), 'prompts', 'resource-analysis.md');
+    const template = fs.readFileSync(promptPath, 'utf8');
+    // Get available resources from solution or use defaults
+    const availableResources = currentSolution.availableResources || {
+        resources: [],
+        custom: []
+    };
+    // Extract resource types for analysis
+    const availableResourceTypes = [
+        ...(availableResources.resources || []),
+        ...(availableResources.custom || [])
+    ].map((r) => r.kind || r);
+    const analysisPrompt = template
+        .replace('{current_solution}', JSON.stringify(currentSolution, null, 2))
+        .replace('{user_request}', openResponse)
+        .replace('{available_resource_types}', JSON.stringify(availableResourceTypes, null, 2));
+    // Initialize Claude integration
+    const apiKey = process.env.ANTHROPIC_API_KEY || 'test-key';
+    const claudeIntegration = new claude_1.ClaudeIntegration(apiKey);
+    context.logger.info('Analyzing resource needs for open question', {
+        openResponse,
+        availableResourceCount: availableResourceTypes.length
+    });
+    const response = await claudeIntegration.sendMessage(analysisPrompt);
+    return parseEnhancementResponse(response.content);
+}
+/**
+ * Phase 2: Apply enhancements based on analysis result
+ */
+async function applySolutionEnhancement(solution, openResponse, analysisResult, context) {
+    if (analysisResult.approach === 'capability_gap') {
+        throw new Error(`Enhancement capability gap: ${analysisResult.reasoning}. ${analysisResult.suggestedAction}`);
+    }
+    if (analysisResult.approach === 'complete_existing_questions') {
+        // Auto-populate existing questions based on user requirements
+        context.logger.info('Auto-populating existing questions based on requirements', {
+            approach: analysisResult.approach,
+            reasoning: analysisResult.reasoning
+        });
+        return autoPopulateQuestions(solution, openResponse, analysisResult);
+    }
+    if (analysisResult.approach === 'add_resources') {
+        // Add new resources and their questions
+        context.logger.info('Adding new resources to solution', {
+            approach: analysisResult.approach,
+            suggestedResources: analysisResult.suggestedResources
+        });
+        return addResourcesAndQuestions(solution, openResponse, analysisResult, context);
+    }
+    // Default: no changes needed
+    return solution;
+}
+/**
+ * Auto-populate existing questions based on user requirements
+ */
+async function autoPopulateQuestions(solution, openResponse, analysisResult) {
+    const promptPath = path.join(process.cwd(), 'prompts', 'solution-enhancement.md');
+    const template = fs.readFileSync(promptPath, 'utf8');
+    const enhancementPrompt = template
+        .replace('{current_solution}', JSON.stringify(solution, null, 2))
+        .replace('{detailed_schemas}', JSON.stringify(solution.schemas || {}, null, 2))
+        .replace('{analysis_result}', JSON.stringify(analysisResult, null, 2))
+        .replace('{open_response}', openResponse);
+    const apiKey = process.env.ANTHROPIC_API_KEY || 'test-key';
+    const claudeIntegration = new claude_1.ClaudeIntegration(apiKey);
+    const response = await claudeIntegration.sendMessage(enhancementPrompt);
+    const enhancementData = parseEnhancementResponse(response.content);
+    if (enhancementData.enhancedSolution) {
+        return enhancementData.enhancedSolution;
+    }
+    return solution;
+}
+/**
+ * Add new resources and their questions to the solution
+ */
+async function addResourcesAndQuestions(solution, openResponse, analysisResult, context) {
+    // For now, implement basic resource addition
+    // This would need more sophisticated question generation for new resources
+    context.logger.warn('Resource addition not fully implemented yet', {
+        suggestedResources: analysisResult.suggestedResources
+    });
+    // TODO: Implement full resource addition with question generation
+    return solution;
+}
+/**
+ * Parse AI response (handles both JSON and text responses)
+ */
+function parseEnhancementResponse(content) {
+    try {
+        // Try to extract JSON from response
+        const jsonMatch = content.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+            return JSON.parse(jsonMatch[0]);
+        }
+        // If no JSON found, return error
+        throw new Error('No valid JSON found in AI response');
+    }
+    catch (error) {
+        throw new Error(`Failed to parse AI response: ${error}`);
+    }
+}
+/**
+ * Enhance solution with AI analysis of open question
+ */
+async function enhanceSolutionWithOpenAnswer(solution, openAnswer, context) {
+    try {
+        context.logger.info('Starting AI enhancement of solution', {
+            solutionId: solution.solutionId,
+            openAnswer
+        });
+        // Phase 1: Analyze what resources are needed
+        const analysisResult = await analyzeResourceNeeds(solution, openAnswer, context);
+        // Phase 2: Apply enhancements based on analysis
+        const enhancedSolution = await applySolutionEnhancement(solution, openAnswer, analysisResult, context);
+        context.logger.info('AI enhancement completed', {
+            approach: analysisResult.approach,
+            changed: enhancedSolution !== solution
+        });
+        return enhancedSolution;
+    }
+    catch (error) {
+        context.logger.error('Solution enhancement failed', error);
+        throw error;
+    }
+}
+/**
+ * Direct MCP tool handler for answerQuestion functionality
+ */
+async function handleAnswerQuestionTool(args, dotAI, logger, requestId) {
+    return await error_handling_1.ErrorHandler.withErrorHandling(async () => {
+        logger.debug('Handling answerQuestion request', {
+            requestId,
+            solutionId: args?.solutionId,
+            stage: args?.stage,
+            answerCount: Object.keys(args?.answers || {}).length
+        });
+        // Input validation is handled automatically by MCP SDK with Zod schema
+        // args are already validated and typed when we reach this point
+        // Get session directory from environment
+        let sessionDir;
+        try {
+            sessionDir = (0, session_utils_1.getAndValidateSessionDirectory)(args, false); // requireWrite=false for reading
+            logger.debug('Session directory resolved and validated', { sessionDir });
+        }
+        catch (error) {
+            throw error_handling_1.ErrorHandler.createError(error_handling_1.ErrorCategory.VALIDATION, error_handling_1.ErrorSeverity.HIGH, error instanceof Error ? error.message : 'Session directory validation failed', {
+                operation: 'session_directory_validation',
+                component: 'AnswerQuestionTool',
+                requestId,
+                suggestedActions: [
+                    'Ensure session directory exists and is writable',
+                    'Check directory permissions',
+                    'Verify the directory path is correct',
+                    'Verify DOT_AI_SESSION_DIR environment variable is correctly set'
+                ]
+            });
+        }
+        // Load solution file
+        let solution;
+        try {
+            solution = loadSolutionFile(args.solutionId, sessionDir);
+            logger.debug('Solution file loaded successfully', {
+                solutionId: args.solutionId,
+                hasQuestions: !!solution.questions
+            });
+        }
+        catch (error) {
+            throw error_handling_1.ErrorHandler.createError(error_handling_1.ErrorCategory.VALIDATION, error_handling_1.ErrorSeverity.HIGH, error instanceof Error ? error.message : 'Failed to load solution file', {
+                operation: 'solution_file_loading',
+                component: 'AnswerQuestionTool',
+                requestId,
+                suggestedActions: [
+                    'Verify the solution ID exists in the session directory',
+                    'Check that the solution file is valid JSON',
+                    'Ensure the solution was selected by chooseSolution tool',
+                    'List available solution files in the session directory'
+                ]
+            });
+        }
+        // Stage-based validation and workflow
+        const stageState = getCurrentStage(solution);
+        // Validate stage transition
+        const transitionResult = validateStageTransition(stageState.currentStage, args.stage);
+        if (!transitionResult.valid) {
+            const response = {
+                status: 'stage_error',
+                solutionId: args.solutionId,
+                error: 'invalid_transition',
+                expected: stageState.currentStage,
+                received: args.stage,
+                message: transitionResult.error,
+                nextStage: stageState.nextStage,
+                timestamp: new Date().toISOString()
+            };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(response, null, 2)
+                    }
+                ]
+            };
+        }
+        // Validate answers against questions for the requested stage
+        const stageQuestions = getQuestionsForStage(solution, args.stage);
+        const validationErrors = [];
+        for (const [questionId, answer] of Object.entries(args.answers)) {
+            // For open stage, handle special case since open question doesn't have 'id' property
+            if (args.stage === 'open') {
+                // Only allow 'open' as the question ID for open stage
+                if (questionId !== 'open') {
+                    validationErrors.push(`Unknown question ID '${questionId}' for stage '${args.stage}'. Open stage only accepts 'open' as question ID.`);
+                    continue;
+                }
+                // Skip further validation for open stage as it doesn't follow Question interface
+                continue;
+            }
+            const question = stageQuestions.find(q => q.id === questionId);
+            if (!question) {
+                validationErrors.push(`Unknown question ID '${questionId}' for stage '${args.stage}'`);
+                continue;
+            }
+            const error = validateAnswer(answer, question);
+            if (error) {
+                validationErrors.push(error);
+            }
+        }
+        if (validationErrors.length > 0) {
+            const response = {
+                status: 'stage_error',
+                solutionId: args.solutionId,
+                error: 'validation_failed',
+                validationErrors,
+                currentStage: args.stage,
+                message: 'Answer validation failed for stage questions',
+                timestamp: new Date().toISOString()
+            };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(response, null, 2)
+                    }
+                ]
+            };
+        }
+        // Update solution with answers for the current stage
+        if (args.stage === 'open') {
+            // Handle open question
+            const openAnswer = args.answers.open;
+            if (openAnswer && solution.questions.open) {
+                solution.questions.open.answer = openAnswer;
+            }
+        }
+        else {
+            // Handle structured questions
+            for (const [questionId, answer] of Object.entries(args.answers)) {
+                const question = stageQuestions.find(q => q.id === questionId);
+                if (question) {
+                    question.answer = answer;
+                }
+            }
+            // If empty answers provided for skippable stage, mark all questions as skipped
+            if (Object.keys(args.answers).length === 0 && (args.stage === 'basic' || args.stage === 'advanced')) {
+                for (const question of stageQuestions) {
+                    if (question.answer === undefined) {
+                        question.answer = null; // Mark as explicitly skipped
+                    }
+                }
+            }
+        }
+        // Save solution with answers
+        try {
+            saveSolutionFile(solution, args.solutionId, sessionDir);
+            logger.info('Solution updated with stage answers', {
+                solutionId: args.solutionId,
+                stage: args.stage,
+                answerCount: Object.keys(args.answers).length
+            });
+        }
+        catch (error) {
+            throw error_handling_1.ErrorHandler.createError(error_handling_1.ErrorCategory.STORAGE, error_handling_1.ErrorSeverity.HIGH, 'Failed to save solution file', {
+                operation: 'solution_file_saving',
+                component: 'AnswerQuestionTool',
+                requestId,
+                suggestedActions: [
+                    'Check session directory write permissions',
+                    'Ensure adequate disk space',
+                    'Verify solution JSON is valid'
+                ]
+            });
+        }
+        // Handle open stage completion (triggers manifest generation)
+        if (args.stage === 'open') {
+            const openAnswer = args.answers.open;
+            // Enhance solution with AI analysis if open answer provided
+            if (openAnswer && openAnswer !== 'N/A') {
+                try {
+                    logger.info('Starting AI enhancement based on open question', {
+                        solutionId: args.solutionId,
+                        openAnswer
+                    });
+                    solution = await enhanceSolutionWithOpenAnswer(solution, openAnswer, { requestId, logger, dotAI });
+                    // Save enhanced solution
+                    saveSolutionFile(solution, args.solutionId, sessionDir);
+                    logger.info('Enhanced solution saved', {
+                        solutionId: args.solutionId,
+                        hasOpenAnswer: !!openAnswer
+                    });
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    // Check if this is a capability gap error (should fail the entire operation)
+                    if (errorMessage.includes('Enhancement capability gap') || errorMessage.includes('capability_gap')) {
+                        logger.error('Capability gap detected, failing operation', error);
+                        throw error; // Re-throw capability gap errors to fail the entire operation
+                    }
+                    // For other errors (AI service issues, parsing errors), continue with original solution
+                    logger.error('AI enhancement failed due to service issue, continuing with original solution', error);
+                }
+            }
+            // Extract all user answers for handoff
+            const userAnswers = {};
+            // Extract from all question categories
+            const questionCategories = ['required', 'basic', 'advanced'];
+            for (const category of questionCategories) {
+                const questions = solution.questions[category] || [];
+                for (const question of questions) {
+                    if (question.answer !== undefined && question.answer !== null) {
+                        userAnswers[question.id] = question.answer;
+                    }
+                }
+            }
+            // Include open answer if provided
+            if (openAnswer) {
+                userAnswers.open = openAnswer;
+            }
+            const response = {
+                status: 'ready_for_manifest_generation',
+                solutionId: args.solutionId,
+                message: `Configuration complete. Ready to generate deployment manifests.`,
+                solutionData: {
+                    primaryResources: solution.resources || [],
+                    type: solution.type || 'single',
+                    description: solution.description || '',
+                    userAnswers: userAnswers,
+                    hasOpenRequirements: !!(openAnswer && openAnswer !== 'N/A')
+                },
+                nextAction: 'generateManifests',
+                guidance: 'Configuration complete. Ready to generate Kubernetes manifests for deployment.',
+                agentInstructions: 'All configuration stages are now complete. You may proceed to generate Kubernetes manifests using the generateManifests tool.',
+                timestamp: new Date().toISOString()
+            };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(response, null, 2)
+                    }
+                ]
+            };
+        }
+        // Regular stage flow: determine next stage and return questions
+        const newStageState = getCurrentStage(solution);
+        // If stage is complete, move to next stage
+        const nextStageQuestions = getQuestionsForStage(solution, newStageState.currentStage);
+        const response = {
+            status: 'stage_questions',
+            solutionId: args.solutionId,
+            currentStage: newStageState.currentStage,
+            questions: nextStageQuestions,
+            nextStage: newStageState.nextStage,
+            message: getStageMessage(newStageState.currentStage),
+            guidance: getStageGuidance(newStageState.currentStage),
+            agentInstructions: getAgentInstructions(newStageState.currentStage),
+            nextAction: 'answerQuestion',
+            timestamp: new Date().toISOString()
+        };
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(response, null, 2)
+                }
+            ]
+        };
+    }, {
+        operation: 'answer_question',
+        component: 'AnswerQuestionTool',
+        requestId,
+        input: args
+    });
+}