@su-record/vibe 0.1.0

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

@@ -0,0 +1,69 @@
+// Memory management tool - SQLite based (v1.3)
+import { MemoryManager } from '../../lib/MemoryManager.js';
+export const restoreSessionContextDefinition = {
+    name: 'restore_session_context',
+    description: 'restore|revert|go back|복원|되돌려 - Restore previous session context',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            sessionId: { type: 'string', description: 'Session ID to restore' },
+            restoreLevel: { type: 'string', description: 'Level of detail to restore', enum: ['essential', 'detailed', 'complete'] },
+            filterType: { type: 'string', description: 'Filter context by type', enum: ['all', 'progress', 'decisions', 'code-snippets', 'debugging', 'planning'] }
+        },
+        required: ['sessionId']
+    },
+    annotations: {
+        title: 'Restore Session',
+        audience: ['user', 'assistant']
+    }
+};
+export async function restoreSessionContext(args) {
+    const { sessionId, restoreLevel = 'detailed', filterType = 'all' } = args;
+    try {
+        const memoryManager = MemoryManager.getInstance();
+        // Get all context memories
+        let memories = memoryManager.list('context');
+        // Filter by session ID
+        memories = memories.filter(m => m.key.includes(sessionId));
+        // Filter by context type if not 'all'
+        if (filterType !== 'all') {
+            memories = memories.filter(m => {
+                try {
+                    const contextData = JSON.parse(m.value);
+                    return contextData.contextType === filterType;
+                }
+                catch {
+                    return false;
+                }
+            });
+        }
+        const maxItems = restoreLevel === 'essential' ? 3 : restoreLevel === 'detailed' ? 10 : 20;
+        const limitedMemories = memories.slice(0, maxItems);
+        if (limitedMemories.length === 0) {
+            return {
+                content: [{ type: 'text', text: `✗ No context found for session: ${sessionId}` }]
+            };
+        }
+        let response = `✓ Restored ${limitedMemories.length} context item(s) for session: ${sessionId}\n`;
+        limitedMemories.forEach(m => {
+            try {
+                const data = JSON.parse(m.value);
+                response += `\n• ${data.contextType || 'context'} (${data.urgency || 'medium'})`;
+                if (data.summary)
+                    response += `: ${data.summary}`;
+                response += `\n  Time: ${new Date(m.timestamp).toLocaleString()}`;
+            }
+            catch {
+                response += `\n• ${m.key}\n  Time: ${new Date(m.timestamp).toLocaleString()}`;
+            }
+        });
+        return {
+            content: [{ type: 'text', text: response }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `✗ Error: ${error instanceof Error ? error.message : 'Unknown error'}` }]
+        };
+    }
+}

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

@@ -0,0 +1,34 @@
+// Memory management tool - SQLite based (v1.3)
+import { MemoryManager } from '../../lib/MemoryManager.js';
+export const saveMemoryDefinition = {
+    name: 'save_memory',
+    description: '기억해|remember|저장해|save|memorize|keep - Save to long-term memory',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            key: { type: 'string', description: 'Memory key/identifier' },
+            value: { type: 'string', description: 'Information to save' },
+            category: { type: 'string', description: 'Memory category', enum: ['project', 'personal', 'code', 'notes'] }
+        },
+        required: ['key', 'value']
+    },
+    annotations: {
+        title: 'Save Memory',
+        audience: ['user', 'assistant']
+    }
+};
+export async function saveMemory(args) {
+    const { key: memoryKey, value: memoryValue, category = 'general' } = args;
+    try {
+        const memoryManager = MemoryManager.getInstance();
+        memoryManager.save(memoryKey, memoryValue, category);
+        return {
+            content: [{ type: 'text', text: `✓ Saved: ${memoryKey}\nCategory: ${category}` }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `✗ Error: ${error instanceof Error ? error.message : 'Unknown error'}` }]
+        };
+    }
+}

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

@@ -0,0 +1,37 @@
+// Memory management tool - completely independent
+import { MemoryManager } from '../../lib/MemoryManager.js';
+export const searchMemoriesDefinition = {
+    name: 'search_memories',
+    description: '찾아|검색|기억 중에|search|find|look for - Search memories by content',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: 'Search query' },
+            category: { type: 'string', description: 'Category to search in' }
+        },
+        required: ['query']
+    },
+    annotations: {
+        title: 'Search Memories',
+        audience: ['user', 'assistant']
+    }
+};
+export async function searchMemoriesHandler(args) {
+    const { query, category: searchCategory } = args;
+    try {
+        const mm = MemoryManager.getInstance();
+        const results = mm.search(query);
+        const resultList = results.map(m => `• ${m.key} (${m.category}): ${m.value.substring(0, 100)}${m.value.length > 100 ? '...' : ''}`).join('\n');
+        return {
+            content: [{
+                    type: 'text',
+                    text: `✓ Found ${results.length} matches for "${query}":\n${resultList || 'None'}`
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `✗ Error: ${error instanceof Error ? error.message : 'Unknown error'}` }]
+        };
+    }
+}

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

@@ -0,0 +1,100 @@
+// 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

@@ -0,0 +1,46 @@
+// 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

@@ -0,0 +1,166 @@
+// 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

@@ -0,0 +1,119 @@
+// 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 }]
+    };
+}