@su-record/vibe 0.1.0

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

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

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

@@ -0,0 +1,156 @@
+// Planning tool - completely independent
+export const generatePrdDefinition = {
+    name: 'generate_prd',
+    description: 'PRD|요구사항 문서|제품 요구사항|product requirements|requirements document|spec document - Generate Product Requirements Document',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            productName: { type: 'string', description: 'Name of the product/feature' },
+            productVision: { type: 'string', description: 'High-level vision and goals' },
+            targetAudience: { type: 'string', description: 'Target users and stakeholders' },
+            businessObjectives: { type: 'string', description: 'Business goals and success metrics' },
+            functionalRequirements: { type: 'string', description: 'Key features and functionality' },
+            constraints: { type: 'string', description: 'Technical/business constraints' }
+        },
+        required: ['productName', 'productVision']
+    },
+    annotations: {
+        title: 'Generate PRD',
+        audience: ['user', 'assistant']
+    }
+};
+export async function generatePrd(args) {
+    const { productName, productVision, targetAudience = 'General users', businessObjectives = 'Improve user experience and business value', functionalRequirements = 'Core functionality to be defined', constraints = 'Standard technical and budget constraints' } = args;
+    const prd = {
+        action: 'generate_prd',
+        product: productName,
+        document: {
+            title: `Product Requirements Document: ${productName}`,
+            version: '1.0',
+            date: new Date().toISOString().split('T')[0],
+            sections: {
+                executiveSummary: {
+                    title: 'Executive Summary',
+                    content: `${productName} is designed to ${productVision}. This document outlines the requirements, scope, and implementation strategy for delivering value to ${targetAudience}.`
+                },
+                productOverview: {
+                    title: 'Product Overview',
+                    vision: productVision,
+                    objectives: businessObjectives,
+                    targetUsers: targetAudience,
+                    successMetrics: [
+                        'User adoption rate',
+                        'Feature usage metrics',
+                        'User satisfaction score',
+                        'Business impact measurement'
+                    ]
+                },
+                functionalRequirements: {
+                    title: 'Functional Requirements',
+                    description: functionalRequirements,
+                    coreFeatures: [
+                        'User authentication and management',
+                        'Core functionality implementation',
+                        'Data processing and storage',
+                        'User interface and experience',
+                        'Integration capabilities'
+                    ],
+                    userFlows: [
+                        'User onboarding process',
+                        'Main feature usage flow',
+                        'Error handling and recovery',
+                        'Administrative functions'
+                    ]
+                },
+                nonFunctionalRequirements: {
+                    title: 'Non-Functional Requirements',
+                    performance: 'Fast response times (<2s), high availability (99.9%)',
+                    security: 'Data encryption, secure authentication, privacy compliance',
+                    scalability: 'Support growing user base and data volume',
+                    usability: 'Intuitive interface, accessibility standards',
+                    compatibility: 'Cross-platform support, browser compatibility'
+                },
+                constraints: {
+                    title: 'Constraints and Assumptions',
+                    technical: constraints,
+                    timeline: 'Development timeline to be defined based on scope',
+                    budget: 'Budget allocation for development and infrastructure',
+                    resources: 'Team capacity and skill requirements'
+                },
+                implementationPlan: {
+                    title: 'Implementation Strategy',
+                    phases: [
+                        'Phase 1: Core functionality development',
+                        'Phase 2: Advanced features and integrations',
+                        'Phase 3: Performance optimization and scaling',
+                        'Phase 4: Launch and post-launch improvements'
+                    ],
+                    riskMitigation: [
+                        'Technical risk assessment and mitigation',
+                        'Resource and timeline risk management',
+                        'Market and user acceptance risks',
+                        'Compliance and security considerations'
+                    ]
+                }
+            }
+        },
+        recommendations: [
+            'Conduct user research to validate assumptions',
+            'Create detailed wireframes and prototypes',
+            'Define detailed acceptance criteria for each feature',
+            'Set up monitoring and analytics for success metrics',
+            'Plan for iterative development and feedback loops'
+        ],
+        status: 'success'
+    };
+    const formattedPrd = `# ${prd.document.title}
+
+**Version:** ${prd.document.version}  
+**Date:** ${prd.document.date}
+
+## ${prd.document.sections.executiveSummary.title}
+${prd.document.sections.executiveSummary.content}
+
+## ${prd.document.sections.productOverview.title}
+**Vision:** ${prd.document.sections.productOverview.vision}
+**Objectives:** ${prd.document.sections.productOverview.objectives}
+**Target Users:** ${prd.document.sections.productOverview.targetUsers}
+
+**Success Metrics:**
+${prd.document.sections.productOverview.successMetrics.map(metric => `- ${metric}`).join('\n')}
+
+## ${prd.document.sections.functionalRequirements.title}
+${prd.document.sections.functionalRequirements.description}
+
+**Core Features:**
+${prd.document.sections.functionalRequirements.coreFeatures.map(feature => `- ${feature}`).join('\n')}
+
+**User Flows:**
+${prd.document.sections.functionalRequirements.userFlows.map(flow => `- ${flow}`).join('\n')}
+
+## ${prd.document.sections.nonFunctionalRequirements.title}
+- **Performance:** ${prd.document.sections.nonFunctionalRequirements.performance}
+- **Security:** ${prd.document.sections.nonFunctionalRequirements.security}
+- **Scalability:** ${prd.document.sections.nonFunctionalRequirements.scalability}
+- **Usability:** ${prd.document.sections.nonFunctionalRequirements.usability}
+- **Compatibility:** ${prd.document.sections.nonFunctionalRequirements.compatibility}
+
+## ${prd.document.sections.constraints.title}
+- **Technical:** ${prd.document.sections.constraints.technical}
+- **Timeline:** ${prd.document.sections.constraints.timeline}
+- **Budget:** ${prd.document.sections.constraints.budget}
+- **Resources:** ${prd.document.sections.constraints.resources}
+
+## ${prd.document.sections.implementationPlan.title}
+**Development Phases:**
+${prd.document.sections.implementationPlan.phases.map(phase => `- ${phase}`).join('\n')}
+
+**Risk Mitigation:**
+${prd.document.sections.implementationPlan.riskMitigation.map(risk => `- ${risk}`).join('\n')}
+
+## Recommendations
+${prd.recommendations.map(rec => `- ${rec}`).join('\n')}`;
+    return {
+        content: [{ type: 'text', text: formattedPrd }]
+    };
+}

package/mcp/dist/tools/prompt/analyzePrompt.js

@@ -0,0 +1,145 @@
+// Prompt analysis tool - completely independent
+export const analyzePromptDefinition = {
+    name: 'analyze_prompt',
+    description: '프롬프트 분석|평가|점수|얼마나 좋은지|analyze prompt|rate this|score|how good|prompt quality - Analyze prompt quality',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            prompt: { type: 'string', description: 'Prompt to analyze' },
+            criteria: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Specific criteria to evaluate (default: all)'
+            }
+        },
+        required: ['prompt']
+    },
+    annotations: {
+        title: 'Analyze Prompt',
+        audience: ['user', 'assistant']
+    }
+};
+export async function analyzePrompt(args) {
+    const { prompt, criteria = ['clarity', 'specificity', 'context', 'structure'] } = args;
+    // Initialize scores with explicit types
+    const scores = {};
+    const feedback = {};
+    // Analyze clarity (0-10)
+    if (criteria.includes('clarity')) {
+        let clarityScore = 5.0;
+        const clarityFeedback = [];
+        if (prompt.length < 20) {
+            clarityScore -= 2.0;
+            clarityFeedback.push('프롬프트가 너무 짧습니다');
+        }
+        if (prompt.includes('?') || /\b(해주세요|부탁|요청)\b/.test(prompt)) {
+            clarityScore += 2.0;
+            clarityFeedback.push('명확한 요청 형태 ✓');
+        }
+        if (prompt.split(',').length > 5 || prompt.split('.').length > 10) {
+            clarityScore -= 1.0;
+            clarityFeedback.push('문장이 너무 복잡합니다');
+        }
+        scores.clarity = Math.max(0, Math.min(10, clarityScore));
+        feedback.clarity = clarityFeedback;
+    }
+    // Analyze specificity (0-10)
+    if (criteria.includes('specificity')) {
+        let specificityScore = 5.0;
+        const specificityFeedback = [];
+        const specificKeywords = ['구체적', '정확히', '예시', '예를 들어'];
+        const hasSpecificWords = specificKeywords.some(word => prompt.includes(word));
+        if (hasSpecificWords) {
+            specificityScore += 2.0;
+            specificityFeedback.push('구체적인 표현 사용 ✓');
+        }
+        const techTerms = /\b(JavaScript|Python|React|Node\.js|API|데이터베이스)\b/i;
+        if (techTerms.test(prompt)) {
+            specificityScore += 2.0;
+            specificityFeedback.push('기술 용어 포함 ✓');
+        }
+        if (!prompt.match(/\d+/) && prompt.length > 50) {
+            specificityScore -= 1.0;
+            specificityFeedback.push('수치나 구체적 데이터 부족');
+        }
+        scores.specificity = Math.max(0, Math.min(10, specificityScore));
+        feedback.specificity = specificityFeedback;
+    }
+    // Analyze context (0-10)
+    if (criteria.includes('context')) {
+        let contextScore = 5.0;
+        const contextFeedback = [];
+        const contextKeywords = ['배경', '목적', '이유', '상황', '현재', '문제'];
+        const contextCount = contextKeywords.filter(word => prompt.includes(word)).length;
+        contextScore += contextCount * 1.5;
+        if (contextCount > 0) {
+            contextFeedback.push(`배경 정보 포함 (${contextCount}개 키워드) ✓`);
+        }
+        else {
+            contextFeedback.push('배경 정보 부족');
+        }
+        if (prompt.split('\n').length > 2) {
+            contextScore += 1.0;
+            contextFeedback.push('구조화된 설명 ✓');
+        }
+        scores.context = Math.max(0, Math.min(10, contextScore));
+        feedback.context = contextFeedback;
+    }
+    // Analyze structure (0-10)
+    if (criteria.includes('structure')) {
+        let structureScore = 5.0;
+        const structureFeedback = [];
+        if (prompt.includes('\n')) {
+            structureScore += 2.0;
+            structureFeedback.push('줄바꿈 사용 ✓');
+        }
+        if (/[1-9]\.|[-•]/.test(prompt)) {
+            structureScore += 2.0;
+            structureFeedback.push('목록 형식 사용 ✓');
+        }
+        if (prompt.includes('**') || prompt.includes('##')) {
+            structureScore += 1.0;
+            structureFeedback.push('마크다운 형식 사용 ✓');
+        }
+        scores.structure = Math.max(0, Math.min(10, structureScore));
+        feedback.structure = structureFeedback;
+    }
+    // Calculate total score
+    const totalScore = Object.values(scores).reduce((a, b) => a + b, 0) / Object.keys(scores).length;
+    // Generate recommendations
+    const recommendations = [];
+    if (scores.clarity < 6) {
+        recommendations.push('💡 질문이나 요청을 더 명확하게 표현하세요');
+    }
+    if (scores.specificity < 6) {
+        recommendations.push('💡 구체적인 예시나 기술 사양을 추가하세요');
+    }
+    if (scores.context < 6) {
+        recommendations.push('💡 작업의 배경과 목적을 설명하세요');
+    }
+    if (scores.structure < 6) {
+        recommendations.push('💡 번호나 불릿 포인트로 구조화하세요');
+    }
+    // Identify strengths and weaknesses
+    const strengths = Object.entries(scores)
+        .filter(([_, score]) => score >= 7)
+        .map(([category, score]) => `✨ ${category}: 우수함 (${score.toFixed(1)}/10)`);
+    const weaknesses = Object.entries(scores)
+        .filter(([_, score]) => score < 5)
+        .map(([category, score]) => `⚠️ ${category}: 개선 필요 (${score.toFixed(1)}/10)`);
+    const analysis = {
+        action: 'analyze_prompt',
+        prompt,
+        totalScore: parseFloat(totalScore.toFixed(1)),
+        scores: Object.fromEntries(Object.entries(scores).map(([k, v]) => [k, parseFloat(v.toFixed(1))])),
+        feedback,
+        strengths,
+        weaknesses,
+        recommendations,
+        grade: totalScore >= 8 ? 'A' : totalScore >= 6 ? 'B' : totalScore >= 4 ? 'C' : 'D',
+        status: 'success'
+    };
+    return {
+        content: [{ type: 'text', text: `Score: ${analysis.totalScore}/10 (Grade: ${analysis.grade})\n\nScores:\n${Object.entries(analysis.scores).map(([k, v]) => `- ${k}: ${v}/10`).join('\n')}\n\nStrengths:\n${analysis.strengths.length > 0 ? analysis.strengths.join('\n') : 'None identified'}\n\nWeaknesses:\n${analysis.weaknesses.length > 0 ? analysis.weaknesses.join('\n') : 'None identified'}\n\nRecommendations:\n${analysis.recommendations.map(r => `- ${r}`).join('\n')}` }]
+    };
+}

package/mcp/dist/tools/prompt/enhancePrompt.js

@@ -0,0 +1,105 @@
+// Prompt enhancement tool - completely independent
+export const enhancePromptDefinition = {
+    name: 'enhance_prompt',
+    description: '구체적으로|자세히|명확하게|더 구체적으로|be specific|more detail|clarify|elaborate|vague - Transform vague requests',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            prompt: { type: 'string', description: 'Original prompt to enhance' },
+            context: { type: 'string', description: 'Additional context or project information' },
+            enhancement_type: {
+                type: 'string',
+                enum: ['clarity', 'specificity', 'context', 'all'],
+                description: 'Type of enhancement (default: all)'
+            }
+        },
+        required: ['prompt']
+    },
+    annotations: {
+        title: 'Enhance Prompt',
+        audience: ['user', 'assistant']
+    }
+};
+export async function enhancePrompt(args) {
+    const { prompt, context = '', enhancement_type = 'all' } = args;
+    // Enhancement logic
+    const enhancements = {
+        clarity: [],
+        specificity: [],
+        context: [],
+        structure: []
+    };
+    // Analyze original prompt
+    const promptLength = prompt.length;
+    const hasQuestion = prompt.includes('?');
+    const hasSpecificTerms = /\b(구현|개발|수정|분석|디버그|리팩토링)\b/i.test(prompt);
+    // Apply enhancements based on type
+    if (enhancement_type === 'clarity' || enhancement_type === 'all') {
+        if (promptLength < 20) {
+            enhancements.clarity.push('더 구체적인 설명 추가');
+        }
+        if (!hasQuestion && !hasSpecificTerms) {
+            enhancements.clarity.push('명확한 요청이나 질문 형태로 변환');
+        }
+    }
+    if (enhancement_type === 'specificity' || enhancement_type === 'all') {
+        if (!prompt.match(/\b(언어|프레임워크|라이브러리|버전)\b/)) {
+            enhancements.specificity.push('기술 스택 명시');
+        }
+        if (!prompt.match(/\b(입력|출력|결과|형식)\b/)) {
+            enhancements.specificity.push('예상 입출력 정의');
+        }
+    }
+    if (enhancement_type === 'context' || enhancement_type === 'all') {
+        if (!prompt.match(/\b(목적|이유|배경|상황)\b/)) {
+            enhancements.context.push('작업 목적과 배경 추가');
+        }
+        if (context) {
+            enhancements.context.push('제공된 컨텍스트 통합');
+        }
+    }
+    // Generate enhanced prompt
+    let enhancedPrompt = prompt;
+    // Build enhanced version
+    const components = [];
+    // Add objective
+    components.push(`**목표**: ${prompt}`);
+    // Add context if provided
+    if (context) {
+        components.push(`**배경**: ${context}`);
+    }
+    // Add specific requirements based on analysis
+    const requirements = [];
+    if (enhancements.specificity.includes('기술 스택 명시')) {
+        requirements.push('- 사용할 언어/프레임워크를 명시해주세요');
+    }
+    if (enhancements.specificity.includes('예상 입출력 정의')) {
+        requirements.push('- 예상되는 입력과 출력 형식을 설명해주세요');
+    }
+    if (requirements.length > 0) {
+        components.push(`**요구사항**:\n${requirements.join('\n')}`);
+    }
+    // Add quality considerations
+    const quality = [
+        '- 에러 처리 포함',
+        '- 테스트 가능한 구조',
+        '- 확장 가능한 설계'
+    ];
+    components.push(`**품질 기준**:\n${quality.join('\n')}`);
+    enhancedPrompt = components.join('\n\n');
+    const result = {
+        action: 'enhance_prompt',
+        original: prompt,
+        enhanced: enhancedPrompt,
+        enhancements,
+        improvements: [
+            enhancements.clarity.length > 0 ? `명확성 개선 (${enhancements.clarity.length}개)` : null,
+            enhancements.specificity.length > 0 ? `구체성 추가 (${enhancements.specificity.length}개)` : null,
+            enhancements.context.length > 0 ? `맥락 보강 (${enhancements.context.length}개)` : null
+        ].filter(Boolean),
+        status: 'success'
+    };
+    return {
+        content: [{ type: 'text', text: `Original: ${prompt}\n\nEnhanced:\n${enhancedPrompt}\n\nImprovements: ${result.improvements.join(', ')}` }]
+    };
+}