@su-record/vibe 0.1.2 → 0.1.4

package/mcp/dist/tools/memory/startSession.js

@@ -1,100 +0,0 @@
-// Memory management tool - SQLite based (v1.3)
-import { MemoryManager } from '../../lib/MemoryManager.js';
-import { promises as fs } from 'fs';
-import path from 'path';
-const GUIDES_DIR = path.join(process.cwd(), 'guides');
-const GUIDES_FILE = path.join(GUIDES_DIR, 'coding_guides.json');
-async function ensureGuidesDir() {
-    try {
-        await fs.access(GUIDES_DIR);
-    }
-    catch {
-        await fs.mkdir(GUIDES_DIR, { recursive: true });
-    }
-}
-async function loadGuides() {
-    try {
-        await ensureGuidesDir();
-        const data = await fs.readFile(GUIDES_FILE, 'utf-8');
-        return JSON.parse(data);
-    }
-    catch {
-        return [];
-    }
-}
-export const startSessionDefinition = {
-    name: 'start_session',
-    description: 'hi-ai|hello|안녕|하이아이 - Start session with context',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            greeting: { type: 'string', description: 'Greeting message that triggered this action (e.g., "하이아이", "hi-ai")' },
-            loadMemory: { type: 'boolean', description: 'Load relevant project memories (default: true)' },
-            loadGuides: { type: 'boolean', description: 'Load applicable coding guides (default: true)' },
-            restoreContext: { type: 'boolean', description: 'Restore previous session context (default: true)' }
-        },
-        required: []
-    },
-    annotations: {
-        title: 'Start Session',
-        audience: ['user', 'assistant']
-    }
-};
-export async function startSession(args) {
-    const { greeting = '', loadMemory = true, loadGuides: shouldLoadGuides = true, restoreContext = true } = args;
-    try {
-        const memoryManager = MemoryManager.getInstance();
-        let summary = `${greeting ? greeting + '! ' : ''}Session started.\n`;
-        // Load relevant project memories
-        if (loadMemory) {
-            const projectMemories = memoryManager.list('project');
-            const codeMemories = memoryManager.list('code');
-            const memories = [...projectMemories, ...codeMemories].slice(0, 5);
-            if (memories.length > 0) {
-                summary += `\nRecent Project Info:\n`;
-                memories.forEach(mem => {
-                    const preview = mem.value.substring(0, 80);
-                    summary += `  • ${mem.key}: ${preview}${mem.value.length > 80 ? '...' : ''}\n`;
-                });
-            }
-        }
-        // Load coding guides
-        if (shouldLoadGuides) {
-            const allGuides = await loadGuides();
-            const guides = allGuides
-                .sort((a, b) => new Date(b.lastUpdated).getTime() - new Date(a.lastUpdated).getTime())
-                .slice(0, 3);
-            if (guides.length > 0) {
-                summary += `\nActive Coding Guides:\n`;
-                guides.forEach(guide => {
-                    summary += `  • ${guide.name} (${guide.category}): ${guide.description}\n`;
-                });
-            }
-        }
-        // Restore context
-        if (restoreContext) {
-            const contextMemories = memoryManager.list('context').slice(0, 3);
-            if (contextMemories.length > 0) {
-                summary += `\nPrevious Context:\n`;
-                contextMemories.forEach(ctx => {
-                    try {
-                        const data = JSON.parse(ctx.value);
-                        summary += `  • ${data.urgency?.toUpperCase() || 'MEDIUM'} priority from ${new Date(ctx.timestamp).toLocaleString()}\n`;
-                    }
-                    catch {
-                        summary += `  • Context from ${new Date(ctx.timestamp).toLocaleString()}\n`;
-                    }
-                });
-            }
-        }
-        summary += '\nReady to continue development! What would you like to work on?';
-        return {
-            content: [{ type: 'text', text: summary }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: 'text', text: `${greeting ? greeting + '! ' : ''}Session started.\n\nReady to begin! What can I help you with?` }]
-        };
-    }
-}

package/mcp/dist/tools/memory/updateMemory.js

@@ -1,46 +0,0 @@
-// Memory management tool - completely independent
-import { MemoryManager } from '../../lib/MemoryManager.js';
-export const updateMemoryDefinition = {
-    name: 'update_memory',
-    description: '수정해|업데이트|바꿔|update|change|modify|edit - Update existing memory',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            key: { type: 'string', description: 'Memory key to update' },
-            value: { type: 'string', description: 'New value' },
-            append: { type: 'boolean', description: 'Append to existing value' }
-        },
-        required: ['key', 'value']
-    },
-    annotations: {
-        title: 'Update Memory',
-        audience: ['user', 'assistant']
-    }
-};
-export async function updateMemory(args) {
-    const { key: updateKey, value: updateValue, append = false } = args;
-    try {
-        const mm = MemoryManager.getInstance();
-        const existingMemory = mm.recall(updateKey);
-        if (existingMemory) {
-            const newValue = append ? existingMemory.value + ' ' + updateValue : updateValue;
-            mm.update(updateKey, newValue);
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✓ ${append ? 'Appended to' : 'Updated'} memory: "${updateKey}"`
-                    }]
-            };
-        }
-        else {
-            return {
-                content: [{ type: 'text', text: `✗ Memory not found: "${updateKey}". Use save_memory to create new memory.` }]
-            };
-        }
-    }
-    catch (error) {
-        return {
-            content: [{ type: 'text', text: `✗ Error: ${error instanceof Error ? error.message : 'Unknown error'}` }]
-        };
-    }
-}

package/mcp/dist/tools/planning/analyzeRequirements.js

@@ -1,166 +0,0 @@
-// Planning tool - completely independent
-export const analyzeRequirementsDefinition = {
-    name: 'analyze_requirements',
-    description: '요구사항 분석|필요한 것들|requirements analysis|what we need|analyze requirements|필수 기능 - Analyze project requirements',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            requirements: { type: 'string', description: 'List of requirements to analyze' },
-            stakeholders: { type: 'string', description: 'Project stakeholders (e.g., users, admins, developers)' },
-            constraints: { type: 'string', description: 'Project constraints (timeline, budget, technical)' },
-            analysisMethod: { type: 'string', description: 'Analysis method', enum: ['moscow', 'kano', 'value-effort'], default: 'moscow' }
-        },
-        required: ['requirements']
-    },
-    annotations: {
-        title: 'Analyze Requirements',
-        audience: ['user', 'assistant']
-    }
-};
-export async function analyzeRequirements(args) {
-    const { requirements, stakeholders = 'end users, product owner, development team', constraints = 'standard timeline and budget constraints', analysisMethod = 'moscow' } = args;
-    // Parse requirements
-    const requirementList = requirements.split(/[,\n]/).map(r => r.trim()).filter(r => r.length > 0);
-    const stakeholderList = stakeholders.split(',').map(s => s.trim());
-    const analyzedRequirements = requirementList.map((req, index) => {
-        const reqId = `REQ-${String(index + 1).padStart(3, '0')}`;
-        // Determine requirement type
-        let type = 'functional';
-        if (req.toLowerCase().includes('performance') || req.toLowerCase().includes('security') || req.toLowerCase().includes('scalability')) {
-            type = 'non-functional';
-        }
-        else if (req.toLowerCase().includes('business') || req.toLowerCase().includes('revenue') || req.toLowerCase().includes('cost')) {
-            type = 'business';
-        }
-        else if (req.toLowerCase().includes('infrastructure') || req.toLowerCase().includes('architecture') || req.toLowerCase().includes('database')) {
-            type = 'technical';
-        }
-        // Determine priority using MoSCoW
-        let priority = 'should-have';
-        if (req.toLowerCase().includes('critical') || req.toLowerCase().includes('essential') || req.toLowerCase().includes('required')) {
-            priority = 'must-have';
-        }
-        else if (req.toLowerCase().includes('important') || req.toLowerCase().includes('needed')) {
-            priority = 'should-have';
-        }
-        else if (req.toLowerCase().includes('nice') || req.toLowerCase().includes('optional') || req.toLowerCase().includes('enhancement')) {
-            priority = 'could-have';
-        }
-        else if (req.toLowerCase().includes('future') || req.toLowerCase().includes('later') || req.toLowerCase().includes('v2')) {
-            priority = 'wont-have';
-        }
-        // Assess complexity
-        let complexity = 'medium';
-        if (req.length > 100 || req.toLowerCase().includes('complex') || req.toLowerCase().includes('integration') || req.toLowerCase().includes('advanced')) {
-            complexity = 'high';
-        }
-        else if (req.length < 50 || req.toLowerCase().includes('simple') || req.toLowerCase().includes('basic')) {
-            complexity = 'low';
-        }
-        // Assess risk
-        let risk = 'low';
-        if (req.toLowerCase().includes('external') || req.toLowerCase().includes('third-party') || req.toLowerCase().includes('new technology')) {
-            risk = 'high';
-        }
-        else if (req.toLowerCase().includes('integration') || req.toLowerCase().includes('performance') || complexity === 'high') {
-            risk = 'medium';
-        }
-        // Estimate effort
-        let estimatedEffort = '3-5 days';
-        if (complexity === 'high') {
-            estimatedEffort = '1-3 weeks';
-        }
-        else if (complexity === 'low') {
-            estimatedEffort = '1-2 days';
-        }
-        // Determine relevant stakeholders
-        const relevantStakeholders = stakeholderList.filter(stakeholder => {
-            if (type === 'business' && stakeholder.toLowerCase().includes('owner'))
-                return true;
-            if (type === 'technical' && stakeholder.toLowerCase().includes('developer'))
-                return true;
-            if (type === 'functional' && stakeholder.toLowerCase().includes('user'))
-                return true;
-            return true; // Include all by default
-        });
-        return {
-            id: reqId,
-            title: req.length > 50 ? req.substring(0, 47) + '...' : req,
-            description: req,
-            type,
-            priority,
-            complexity,
-            risk,
-            dependencies: [],
-            estimatedEffort,
-            stakeholders: relevantStakeholders
-        };
-    });
-    const analysis = {
-        action: 'analyze_requirements',
-        method: analysisMethod,
-        totalRequirements: analyzedRequirements.length,
-        requirements: analyzedRequirements,
-        priorityBreakdown: {
-            mustHave: analyzedRequirements.filter(r => r.priority === 'must-have').length,
-            shouldHave: analyzedRequirements.filter(r => r.priority === 'should-have').length,
-            couldHave: analyzedRequirements.filter(r => r.priority === 'could-have').length,
-            wontHave: analyzedRequirements.filter(r => r.priority === 'wont-have').length
-        },
-        typeBreakdown: {
-            functional: analyzedRequirements.filter(r => r.type === 'functional').length,
-            nonFunctional: analyzedRequirements.filter(r => r.type === 'non-functional').length,
-            business: analyzedRequirements.filter(r => r.type === 'business').length,
-            technical: analyzedRequirements.filter(r => r.type === 'technical').length
-        },
-        riskAssessment: {
-            high: analyzedRequirements.filter(r => r.risk === 'high').length,
-            medium: analyzedRequirements.filter(r => r.risk === 'medium').length,
-            low: analyzedRequirements.filter(r => r.risk === 'low').length
-        },
-        recommendations: [
-            'Focus on Must-Have requirements for MVP',
-            'Validate high-risk requirements early',
-            'Consider Should-Have items for post-MVP releases',
-            'Review Could-Have items based on resource availability',
-            'Plan technical requirements to support functional ones'
-        ],
-        constraints: constraints,
-        status: 'success'
-    };
-    // Format output
-    let formattedOutput = `# Requirements Analysis\n\n`;
-    formattedOutput += `**Analysis Method:** ${analysisMethod.toUpperCase()}  \n`;
-    formattedOutput += `**Total Requirements:** ${analysis.totalRequirements}  \n`;
-    formattedOutput += `**Constraints:** ${constraints}\n\n`;
-    formattedOutput += `## Priority Breakdown (MoSCoW)\n`;
-    formattedOutput += `- **Must Have:** ${analysis.priorityBreakdown.mustHave}\n`;
-    formattedOutput += `- **Should Have:** ${analysis.priorityBreakdown.shouldHave}\n`;
-    formattedOutput += `- **Could Have:** ${analysis.priorityBreakdown.couldHave}\n`;
-    formattedOutput += `- **Won't Have:** ${analysis.priorityBreakdown.wontHave}\n\n`;
-    formattedOutput += `## Risk Assessment\n`;
-    formattedOutput += `- **High Risk:** ${analysis.riskAssessment.high} requirements\n`;
-    formattedOutput += `- **Medium Risk:** ${analysis.riskAssessment.medium} requirements\n`;
-    formattedOutput += `- **Low Risk:** ${analysis.riskAssessment.low} requirements\n\n`;
-    formattedOutput += `## Detailed Requirements\n\n`;
-    // Group by priority
-    const priorities = ['must-have', 'should-have', 'could-have', 'wont-have'];
-    priorities.forEach(priority => {
-        const reqsForPriority = analyzedRequirements.filter(r => r.priority === priority);
-        if (reqsForPriority.length > 0) {
-            formattedOutput += `### ${priority.toUpperCase().replace('-', ' ')} (${reqsForPriority.length})\n\n`;
-            reqsForPriority.forEach(req => {
-                formattedOutput += `**${req.id}:** ${req.title}  \n`;
-                formattedOutput += `*Type:* ${req.type} | *Complexity:* ${req.complexity} | *Risk:* ${req.risk} | *Effort:* ${req.estimatedEffort}  \n`;
-                formattedOutput += `*Stakeholders:* ${req.stakeholders.join(', ')}\n\n`;
-            });
-        }
-    });
-    formattedOutput += `## Recommendations\n`;
-    analysis.recommendations.forEach(rec => {
-        formattedOutput += `- ${rec}\n`;
-    });
-    return {
-        content: [{ type: 'text', text: formattedOutput }]
-    };
-}

package/mcp/dist/tools/planning/createUserStories.js

@@ -1,119 +0,0 @@
-// Planning tool - completely independent
-export const createUserStoriesDefinition = {
-    name: 'create_user_stories',
-    description: '스토리|사용자 스토리|user story|user stories|as a user - Generate user stories from requirements',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            features: { type: 'string', description: 'List of features or requirements to convert to user stories' },
-            userTypes: { type: 'string', description: 'Types of users (e.g., admin, customer, guest)' },
-            priority: { type: 'string', description: 'Default priority level', enum: ['high', 'medium', 'low'] },
-            includeAcceptanceCriteria: { type: 'boolean', description: 'Include acceptance criteria for each story' }
-        },
-        required: ['features']
-    },
-    annotations: {
-        title: 'Create User Stories',
-        audience: ['user', 'assistant']
-    }
-};
-export async function createUserStories(args) {
-    const { features, userTypes = 'user, admin, guest', priority = 'medium', includeAcceptanceCriteria = true } = args;
-    // Parse features into individual items
-    const featureList = features.split(/[,\n]/).map(f => f.trim()).filter(f => f.length > 0);
-    const userTypeList = userTypes.split(',').map(u => u.trim());
-    const userStories = featureList.map((feature, index) => {
-        const storyId = `US-${String(index + 1).padStart(3, '0')}`;
-        // Determine user type based on feature content
-        let selectedUserType = userTypeList[0];
-        if (feature.toLowerCase().includes('admin') || feature.toLowerCase().includes('manage')) {
-            selectedUserType = userTypeList.find(u => u.toLowerCase().includes('admin')) || selectedUserType;
-        }
-        else if (feature.toLowerCase().includes('guest') || feature.toLowerCase().includes('browse')) {
-            selectedUserType = userTypeList.find(u => u.toLowerCase().includes('guest')) || selectedUserType;
-        }
-        // Extract functionality and benefit
-        const functionality = feature;
-        let benefit = 'to achieve my goals efficiently';
-        // Try to infer benefit from common patterns
-        if (feature.toLowerCase().includes('search'))
-            benefit = 'to find relevant information quickly';
-        else if (feature.toLowerCase().includes('save') || feature.toLowerCase().includes('store'))
-            benefit = 'to preserve my data for future use';
-        else if (feature.toLowerCase().includes('share'))
-            benefit = 'to collaborate with others effectively';
-        else if (feature.toLowerCase().includes('track') || feature.toLowerCase().includes('monitor'))
-            benefit = 'to stay informed about important changes';
-        else if (feature.toLowerCase().includes('customize') || feature.toLowerCase().includes('configure'))
-            benefit = 'to tailor the experience to my needs';
-        // Generate acceptance criteria
-        const acceptanceCriteria = includeAcceptanceCriteria ? [
-            `Given I am a ${selectedUserType}, when I access the ${functionality.toLowerCase()} feature, then it should be available and functional`,
-            `When I use the ${functionality.toLowerCase()} feature, then it should provide clear feedback about the action`,
-            `The ${functionality.toLowerCase()} feature should handle errors gracefully and provide helpful messages`,
-            `The feature should be accessible and usable across different devices and browsers`
-        ] : [];
-        // Determine priority based on feature content
-        let storyPriority = priority;
-        if (feature.toLowerCase().includes('critical') || feature.toLowerCase().includes('security') || feature.toLowerCase().includes('login')) {
-            storyPriority = 'high';
-        }
-        else if (feature.toLowerCase().includes('nice to have') || feature.toLowerCase().includes('optional')) {
-            storyPriority = 'low';
-        }
-        // Estimate effort based on complexity
-        let estimatedEffort = '3-5 days';
-        if (feature.length > 100 || feature.toLowerCase().includes('complex') || feature.toLowerCase().includes('integration')) {
-            estimatedEffort = '1-2 weeks';
-        }
-        else if (feature.length < 30 || feature.toLowerCase().includes('simple') || feature.toLowerCase().includes('basic')) {
-            estimatedEffort = '1-2 days';
-        }
-        return {
-            id: storyId,
-            title: `${selectedUserType} - ${functionality}`,
-            story: `As a ${selectedUserType}, I want to ${functionality.toLowerCase()}, so that ${benefit}.`,
-            userType: selectedUserType,
-            functionality,
-            benefit,
-            acceptanceCriteria,
-            priority: storyPriority,
-            estimatedEffort,
-            dependencies: []
-        };
-    });
-    const result = {
-        action: 'create_user_stories',
-        totalStories: userStories.length,
-        userTypes: userTypeList,
-        stories: userStories,
-        summary: {
-            high: userStories.filter(s => s.priority === 'high').length,
-            medium: userStories.filter(s => s.priority === 'medium').length,
-            low: userStories.filter(s => s.priority === 'low').length,
-            estimatedTotalEffort: `${userStories.length * 3}-${userStories.length * 7} days`
-        },
-        status: 'success'
-    };
-    // Format output
-    let formattedOutput = `# User Stories\n\n**Total Stories:** ${result.totalStories}  \n**Priority Breakdown:** ${result.summary.high} High, ${result.summary.medium} Medium, ${result.summary.low} Low  \n**Estimated Effort:** ${result.summary.estimatedTotalEffort}\n\n`;
-    userStories.forEach((story, index) => {
-        formattedOutput += `## ${story.id}: ${story.title}\n\n`;
-        formattedOutput += `**Story:** ${story.story}\n\n`;
-        formattedOutput += `**Priority:** ${story.priority.toUpperCase()}  \n`;
-        formattedOutput += `**Estimated Effort:** ${story.estimatedEffort}\n\n`;
-        if (story.acceptanceCriteria.length > 0) {
-            formattedOutput += `**Acceptance Criteria:**\n`;
-            story.acceptanceCriteria.forEach((criteria, i) => {
-                formattedOutput += `${i + 1}. ${criteria}\n`;
-            });
-            formattedOutput += '\n';
-        }
-        if (index < userStories.length - 1) {
-            formattedOutput += '---\n\n';
-        }
-    });
-    return {
-        content: [{ type: 'text', text: formattedOutput }]
-    };
-}

package/mcp/dist/tools/planning/featureRoadmap.js

@@ -1,202 +0,0 @@
-// Planning tool - completely independent
-export const featureRoadmapDefinition = {
-    name: 'feature_roadmap',
-    description: '로드맵|일정|계획표|roadmap|timeline|project plan|development schedule - Generate development roadmap',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            projectName: { type: 'string', description: 'Name of the project' },
-            features: { type: 'string', description: 'List of features to include in roadmap' },
-            timeframe: { type: 'string', description: 'Project timeframe', enum: ['3-months', '6-months', '12-months', 'custom'] },
-            approach: { type: 'string', description: 'Development approach', enum: ['mvp-first', 'phased-rollout', 'big-bang'], default: 'mvp-first' },
-            teamSize: { type: 'number', description: 'Development team size' }
-        },
-        required: ['projectName', 'features']
-    },
-    annotations: {
-        title: 'Feature Roadmap',
-        audience: ['user', 'assistant']
-    }
-};
-export async function featureRoadmap(args) {
-    const { projectName, features, timeframe = '6-months', approach = 'mvp-first', teamSize = 3 } = args;
-    // Parse features
-    const featureList = features.split(/[,\n]/).map(f => f.trim()).filter(f => f.length > 0);
-    // Define phases based on approach
-    let phaseNames = [];
-    if (approach === 'mvp-first') {
-        phaseNames = ['MVP Foundation', 'Core Features', 'Advanced Features', 'Optimization & Scaling'];
-    }
-    else if (approach === 'phased-rollout') {
-        phaseNames = ['Phase 1: Core', 'Phase 2: Enhancement', 'Phase 3: Expansion', 'Phase 4: Innovation'];
-    }
-    else {
-        phaseNames = ['Planning & Setup', 'Development Sprint', 'Integration & Testing', 'Launch & Monitoring'];
-    }
-    // Calculate phase durations
-    const totalMonths = timeframe === '3-months' ? 3 : timeframe === '6-months' ? 6 : timeframe === '12-months' ? 12 : 6;
-    const monthsPerPhase = Math.ceil(totalMonths / phaseNames.length);
-    // Categorize features by priority and complexity
-    const roadmapItems = featureList.map((feature, index) => {
-        const itemId = `F-${String(index + 1).padStart(3, '0')}`;
-        // Determine priority
-        let priority = 'medium';
-        if (feature.toLowerCase().includes('critical') || feature.toLowerCase().includes('core') || feature.toLowerCase().includes('essential')) {
-            priority = 'high';
-        }
-        else if (feature.toLowerCase().includes('enhancement') || feature.toLowerCase().includes('nice') || feature.toLowerCase().includes('optional')) {
-            priority = 'low';
-        }
-        // Determine phase based on priority and approach
-        let phase = phaseNames[1]; // Default to second phase
-        if (priority === 'high' || feature.toLowerCase().includes('mvp') || feature.toLowerCase().includes('basic')) {
-            phase = phaseNames[0];
-        }
-        else if (priority === 'low' || feature.toLowerCase().includes('advanced') || feature.toLowerCase().includes('future')) {
-            phase = phaseNames[Math.min(2, phaseNames.length - 1)];
-        }
-        // Estimate duration
-        let estimatedDuration = '2-3 weeks';
-        if (feature.length > 100 || feature.toLowerCase().includes('complex') || feature.toLowerCase().includes('integration')) {
-            estimatedDuration = '4-6 weeks';
-        }
-        else if (feature.length < 50 || feature.toLowerCase().includes('simple')) {
-            estimatedDuration = '1-2 weeks';
-        }
-        // Generate deliverables
-        const deliverables = [
-            `${feature} implementation`,
-            `Unit and integration tests`,
-            `Documentation and user guides`,
-            `Code review and quality assurance`
-        ];
-        // Generate success criteria
-        const successCriteria = [
-            `Feature functions as specified`,
-            `Meets performance requirements`,
-            `Passes all test cases`,
-            `User acceptance criteria met`
-        ];
-        // Identify potential risks
-        const risks = [];
-        if (feature.toLowerCase().includes('external') || feature.toLowerCase().includes('third-party')) {
-            risks.push('External dependency risk');
-        }
-        if (feature.toLowerCase().includes('performance') || feature.toLowerCase().includes('scalability')) {
-            risks.push('Performance optimization complexity');
-        }
-        if (feature.toLowerCase().includes('security') || feature.toLowerCase().includes('authentication')) {
-            risks.push('Security implementation complexity');
-        }
-        if (risks.length === 0) {
-            risks.push('Standard development risks');
-        }
-        return {
-            id: itemId,
-            title: feature.length > 50 ? feature.substring(0, 47) + '...' : feature,
-            description: feature,
-            phase,
-            priority,
-            estimatedDuration,
-            dependencies: [],
-            deliverables,
-            successCriteria,
-            risks
-        };
-    });
-    // Group features by phase
-    const phases = phaseNames.map((phaseName, index) => {
-        const phaseFeatures = roadmapItems.filter(item => item.phase === phaseName);
-        const phaseGoals = [];
-        if (index === 0) {
-            phaseGoals.push('Establish core functionality', 'Validate core assumptions', 'Build foundation for future features');
-        }
-        else if (index === 1) {
-            phaseGoals.push('Enhance user experience', 'Add key differentiating features', 'Improve system reliability');
-        }
-        else if (index === 2) {
-            phaseGoals.push('Scale system capabilities', 'Add advanced features', 'Optimize performance');
-        }
-        else {
-            phaseGoals.push('Continuous improvement', 'Innovation and experimentation', 'Long-term sustainability');
-        }
-        const milestones = [
-            `${phaseName} features delivered`,
-            `Quality assurance completed`,
-            `User feedback incorporated`,
-            `Metrics and KPIs reviewed`
-        ];
-        return {
-            name: phaseName,
-            duration: `${monthsPerPhase} month${monthsPerPhase > 1 ? 's' : ''}`,
-            goals: phaseGoals,
-            features: phaseFeatures,
-            milestones
-        };
-    });
-    const roadmap = {
-        action: 'feature_roadmap',
-        project: projectName,
-        timeframe,
-        approach,
-        teamSize,
-        phases,
-        summary: {
-            totalFeatures: roadmapItems.length,
-            totalDuration: `${totalMonths} months`,
-            highPriorityFeatures: roadmapItems.filter(f => f.priority === 'high').length,
-            mediumPriorityFeatures: roadmapItems.filter(f => f.priority === 'medium').length,
-            lowPriorityFeatures: roadmapItems.filter(f => f.priority === 'low').length
-        },
-        recommendations: [
-            'Review and validate priorities with stakeholders',
-            'Set up regular milestone reviews and adjustments',
-            'Plan for buffer time between phases for testing',
-            'Consider team capacity and external dependencies',
-            'Establish clear success metrics for each phase'
-        ],
-        status: 'success'
-    };
-    // Format output
-    let formattedOutput = `# ${projectName} - Feature Roadmap\n\n`;
-    formattedOutput += `**Timeframe:** ${timeframe}  \n`;
-    formattedOutput += `**Approach:** ${approach}  \n`;
-    formattedOutput += `**Team Size:** ${teamSize} developers  \n`;
-    formattedOutput += `**Total Features:** ${roadmap.summary.totalFeatures}\n\n`;
-    formattedOutput += `## Overview\n`;
-    formattedOutput += `- **High Priority:** ${roadmap.summary.highPriorityFeatures} features\n`;
-    formattedOutput += `- **Medium Priority:** ${roadmap.summary.mediumPriorityFeatures} features\n`;
-    formattedOutput += `- **Low Priority:** ${roadmap.summary.lowPriorityFeatures} features\n\n`;
-    phases.forEach((phase, index) => {
-        formattedOutput += `## ${phase.name}\n`;
-        formattedOutput += `**Duration:** ${phase.duration}  \n`;
-        formattedOutput += `**Features:** ${phase.features.length}\n\n`;
-        formattedOutput += `### Goals\n`;
-        phase.goals.forEach(goal => {
-            formattedOutput += `- ${goal}\n`;
-        });
-        formattedOutput += '\n';
-        if (phase.features.length > 0) {
-            formattedOutput += `### Features\n`;
-            phase.features.forEach(feature => {
-                formattedOutput += `**${feature.id}:** ${feature.title} (${feature.priority.toUpperCase()})  \n`;
-                formattedOutput += `*Duration:* ${feature.estimatedDuration}  \n`;
-                formattedOutput += `*Key Risks:* ${feature.risks.join(', ')}\n\n`;
-            });
-        }
-        formattedOutput += `### Milestones\n`;
-        phase.milestones.forEach(milestone => {
-            formattedOutput += `- ${milestone}\n`;
-        });
-        if (index < phases.length - 1) {
-            formattedOutput += '\n---\n\n';
-        }
-    });
-    formattedOutput += `\n## Recommendations\n`;
-    roadmap.recommendations.forEach(rec => {
-        formattedOutput += `- ${rec}\n`;
-    });
-    return {
-        content: [{ type: 'text', text: formattedOutput }]
-    };
-}