@su-record/vibe 0.1.0

package/mcp/dist/tools/thinking/formatAsPlan.js

@@ -0,0 +1,73 @@
+// Sequential thinking tool - completely independent
+export const formatAsPlanDefinition = {
+    name: 'format_as_plan',
+    description: '계획으로|정리해줘|체크리스트|format as plan|make a plan|organize this|checklist - Format content into clear plans',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            content: { type: 'string', description: 'Content to format as a plan' },
+            priority: { type: 'string', description: 'Default priority level', enum: ['high', 'medium', 'low'] },
+            includeTimeEstimates: { type: 'boolean', description: 'Include time estimates for each step' },
+            includeCheckboxes: { type: 'boolean', description: 'Include checkboxes for tracking progress' }
+        },
+        required: ['content']
+    },
+    annotations: {
+        title: 'Format as Plan',
+        audience: ['user', 'assistant']
+    }
+};
+export async function formatAsPlan(args) {
+    const { content: planContent, priority = 'medium', includeTimeEstimates = true, includeCheckboxes = true } = args;
+    // Parse content into actionable steps
+    const sentences = planContent.split(/[.!?]+/).filter(s => s.trim().length > 10);
+    const planSteps = sentences.map((sentence, index) => {
+        const stepNumber = index + 1;
+        const cleanSentence = sentence.trim();
+        // Estimate time based on content complexity
+        let timeEstimate = '5min';
+        if (cleanSentence.length > 100)
+            timeEstimate = '15min';
+        else if (cleanSentence.length > 50)
+            timeEstimate = '10min';
+        // Detect priority keywords
+        let stepPriority = priority;
+        if (cleanSentence.match(/urgent|critical|important|first|must/i))
+            stepPriority = 'high';
+        else if (cleanSentence.match(/later|eventually|nice|optional/i))
+            stepPriority = 'low';
+        // Format step
+        let formattedStep = includeCheckboxes ? `${stepNumber}. □ ` : `${stepNumber}. `;
+        formattedStep += cleanSentence;
+        if (includeTimeEstimates)
+            formattedStep += ` (${stepPriority.toUpperCase()}, ${timeEstimate})`;
+        return {
+            number: stepNumber,
+            content: cleanSentence,
+            priority: stepPriority,
+            timeEstimate,
+            formatted: formattedStep
+        };
+    });
+    // Calculate total time
+    const totalMinutes = planSteps.reduce((total, step) => {
+        const minutes = parseInt(step.timeEstimate.replace('min', ''));
+        return total + minutes;
+    }, 0);
+    const planResult = {
+        action: 'format_as_plan',
+        originalContent: planContent,
+        formattedPlan: planSteps.map((s) => s.formatted).join('\n'),
+        steps: planSteps.length,
+        totalEstimatedTime: `${totalMinutes} minutes`,
+        breakdown: {
+            high: planSteps.filter((s) => s.priority === 'high').length,
+            medium: planSteps.filter((s) => s.priority === 'medium').length,
+            low: planSteps.filter((s) => s.priority === 'low').length
+        },
+        status: 'success'
+    };
+    return {
+        content: [{ type: 'text', text: `${planResult.formattedPlan}\n\nTotal: ${planResult.totalEstimatedTime} | Priority: ${planResult.breakdown.high}H ${planResult.breakdown.medium}M ${planResult.breakdown.low}L` }]
+    };
+}

package/mcp/dist/tools/thinking/stepByStepAnalysis.js

@@ -0,0 +1,58 @@
+// Sequential thinking tool - completely independent
+export const stepByStepAnalysisDefinition = {
+    name: 'step_by_step_analysis',
+    description: '단계별|차근차근|하나씩|step by step|one by one|gradually - Perform detailed step-by-step analysis',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            task: { type: 'string', description: 'Task to analyze step by step' },
+            context: { type: 'string', description: 'Additional context for the task' },
+            detailLevel: { type: 'string', description: 'Level of detail', enum: ['basic', 'detailed', 'comprehensive'] }
+        },
+        required: ['task']
+    },
+    annotations: {
+        title: 'Step-by-Step Analysis',
+        audience: ['user', 'assistant']
+    }
+};
+export async function stepByStepAnalysis(args) {
+    const { task, context = '', detailLevel = 'detailed' } = args;
+    const stepCount = detailLevel === 'basic' ? 3 : detailLevel === 'detailed' ? 5 : 7;
+    const stepAnalysis = {
+        action: 'step_by_step_analysis',
+        task,
+        context,
+        detailLevel,
+        steps: Array.from({ length: stepCount }, (_, i) => {
+            const stepNum = i + 1;
+            return {
+                stepNumber: stepNum,
+                title: `Step ${stepNum}: ${task} - Phase ${stepNum}`,
+                description: `Detailed analysis of ${task} in step ${stepNum}`,
+                actions: [
+                    `Analyze requirements for step ${stepNum}`,
+                    `Identify dependencies and prerequisites`,
+                    `Execute the planned actions`,
+                    `Validate results and check for issues`,
+                    `Prepare for next step`
+                ],
+                checkpoints: [
+                    `Verify step ${stepNum} requirements are met`,
+                    `Confirm outputs are as expected`,
+                    `Check for any blocking issues`
+                ],
+                estimatedTime: detailLevel === 'comprehensive' ? `${stepNum * 10} minutes` : `${stepNum * 5} minutes`
+            };
+        }),
+        summary: {
+            totalSteps: stepCount,
+            estimatedTotalTime: detailLevel === 'comprehensive' ? `${stepCount * 35} minutes` : `${stepCount * 20} minutes`,
+            complexity: detailLevel === 'basic' ? 'low' : detailLevel === 'detailed' ? 'medium' : 'high'
+        },
+        status: 'success'
+    };
+    return {
+        content: [{ type: 'text', text: `Task: ${task}\nDetail: ${detailLevel}\nSteps: ${stepCount}\n\n${stepAnalysis.steps.map(s => `Step ${s.stepNumber}: ${s.title}\n  Time: ${s.estimatedTime}\n  Actions: ${s.actions.join(', ')}\n  Checkpoints: ${s.checkpoints.join(', ')}`).join('\n\n')}\n\nTotal Time: ${stepAnalysis.summary.estimatedTotalTime} | Complexity: ${stepAnalysis.summary.complexity}` }]
+    };
+}

package/mcp/dist/tools/thinking/thinkAloudProcess.js

@@ -0,0 +1,75 @@
+// Sequential thinking tool - completely independent
+export const thinkAloudProcessDefinition = {
+    name: 'think_aloud_process',
+    description: '생각해봐|고민해봐|어떻게 생각해|think about it|let me think|reasoning - Generate think-aloud reasoning process',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            scenario: { type: 'string', description: 'Scenario or problem to think through' },
+            perspective: { type: 'string', description: 'Thinking perspective', enum: ['analytical', 'creative', 'systematic', 'critical'] },
+            verbosity: { type: 'string', description: 'Verbosity level', enum: ['concise', 'moderate', 'verbose'] }
+        },
+        required: ['scenario']
+    },
+    annotations: {
+        title: 'Think Aloud',
+        audience: ['user', 'assistant']
+    }
+};
+export async function thinkAloudProcess(args) {
+    const { scenario, perspective = 'analytical', verbosity = 'moderate' } = args;
+    const thoughtCount = verbosity === 'concise' ? 3 : verbosity === 'moderate' ? 5 : 8;
+    const thinkAloudProcess = {
+        action: 'think_aloud_process',
+        scenario,
+        perspective,
+        verbosity,
+        thoughtProcess: Array.from({ length: thoughtCount }, (_, i) => {
+            const thoughtNum = i + 1;
+            let thoughtStyle = '';
+            switch (perspective) {
+                case 'analytical':
+                    thoughtStyle = `Analyzing: Let me examine ${scenario} systematically...`;
+                    break;
+                case 'creative':
+                    thoughtStyle = `Brainstorming: What if I approach ${scenario} differently...`;
+                    break;
+                case 'systematic':
+                    thoughtStyle = `Step ${thoughtNum}: Following systematic approach to ${scenario}...`;
+                    break;
+                case 'critical':
+                    thoughtStyle = `Questioning: What assumptions am I making about ${scenario}...`;
+                    break;
+            }
+            return {
+                stepNumber: thoughtNum,
+                thought: thoughtStyle,
+                reasoning: `In step ${thoughtNum}, I need to consider the implications of ${scenario} from a ${perspective} perspective`,
+                questions: [
+                    `What do I know about this aspect of ${scenario}?`,
+                    `What don't I know yet?`,
+                    `What should I explore next?`
+                ],
+                conclusions: [
+                    `Based on current analysis...`,
+                    `This leads me to think that...`,
+                    `Next I should focus on...`
+                ],
+                confidence: Math.min(95, 60 + (thoughtNum * 5))
+            };
+        }),
+        metacognition: {
+            thinkingStyle: perspective,
+            processEffectiveness: verbosity === 'verbose' ? 'highly detailed' : verbosity === 'moderate' ? 'balanced' : 'efficient',
+            nextSteps: [
+                'Review thinking process for gaps',
+                'Validate conclusions against evidence',
+                'Plan concrete actions based on analysis'
+            ]
+        },
+        status: 'success'
+    };
+    return {
+        content: [{ type: 'text', text: `Scenario: ${scenario}\nPerspective: ${perspective}\nThoughts: ${thoughtCount}\n${thinkAloudProcess.thoughtProcess.map((t, i) => `${i + 1}. ${t.thought} (confidence: ${t.confidence}%)`).join('\n')}\n\nNext: ${thinkAloudProcess.metacognition.nextSteps.join(', ')}` }]
+    };
+}

package/mcp/dist/tools/time/getCurrentTime.js

@@ -0,0 +1,61 @@
+// Time utility tool - completely independent
+export const getCurrentTimeDefinition = {
+    name: 'get_current_time',
+    description: '지금 몇시|현재 시간|몇시야|what time|current time|time now - Get current time',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            format: { type: 'string', description: 'Time format', enum: ['iso', 'local', 'utc', 'timestamp', 'human'] },
+            timezone: { type: 'string', description: 'Timezone (e.g., America/New_York, Asia/Seoul)' }
+        },
+        required: []
+    },
+    annotations: {
+        title: 'Get Current Time',
+        audience: ['user', 'assistant']
+    }
+};
+export async function getCurrentTime(args) {
+    const { format = 'iso', timezone } = args;
+    const now = new Date();
+    let timeResult;
+    switch (format) {
+        case 'iso':
+            timeResult = now.toISOString();
+            break;
+        case 'local':
+            timeResult = now.toLocaleString();
+            break;
+        case 'utc':
+            timeResult = now.toUTCString();
+            break;
+        case 'timestamp':
+            timeResult = Math.floor(now.getTime() / 1000).toString();
+            break;
+        case 'human':
+            const options = {
+                year: 'numeric',
+                month: 'long',
+                day: 'numeric',
+                hour: '2-digit',
+                minute: '2-digit',
+                second: '2-digit',
+                timeZone: timezone
+            };
+            timeResult = now.toLocaleString('en-US', options);
+            break;
+        default:
+            timeResult = now.toISOString();
+    }
+    const currentTimeResult = {
+        action: 'get_current_time',
+        format,
+        timezone: timezone || 'local',
+        result: timeResult,
+        timestamp: now.getTime(),
+        status: 'success'
+    };
+    return {
+        content: [{ type: 'text', text: `Time: ${timeResult}\nFormat: ${format}\nTimezone: ${timezone || 'local'}\nTimestamp: ${now.getTime()}` }]
+    };
+}

package/mcp/dist/tools/ui/previewUiAscii.js

@@ -0,0 +1,232 @@
+// UI Preview tool - ASCII art visualization before development
+export const previewUiAsciiDefinition = {
+    name: 'preview_ui_ascii',
+    description: 'UI 만들어|페이지 개발|페이지 만들어|컴포넌트 작성|레이아웃|화면 구성|create page|build UI|design component|make page|develop page - Preview UI before coding',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            page_name: {
+                type: 'string',
+                description: 'Name of the page or component (e.g., "Login Page", "Dashboard")'
+            },
+            layout_type: {
+                type: 'string',
+                enum: ['sidebar', 'header-footer', 'grid', 'centered', 'split', 'custom'],
+                description: 'Layout structure type (default: header-footer)'
+            },
+            components: {
+                type: 'array',
+                description: 'List of UI components to include',
+                items: {
+                    type: 'object',
+                    properties: {
+                        type: { type: 'string', description: 'Component type (header, sidebar, button, input, card, etc.)' },
+                        label: { type: 'string', description: 'Component label or text' },
+                        position: { type: 'string', description: 'Position in layout (top, left, center, right, bottom)' }
+                    }
+                }
+            },
+            width: {
+                type: 'number',
+                description: 'Preview width in characters (default: 60)'
+            },
+            responsive: {
+                type: 'boolean',
+                description: 'Show mobile view preview (default: false)'
+            }
+        },
+        required: ['page_name', 'components']
+    },
+    annotations: {
+        title: 'Preview UI (ASCII)',
+        audience: ['user', 'assistant']
+    }
+};
+export async function previewUiAscii(args) {
+    const { page_name, layout_type = 'header-footer', components, width = 60, responsive = false } = args;
+    // ASCII art generation
+    const topBorder = '┌' + '─'.repeat(width - 2) + '┐';
+    const bottomBorder = '└' + '─'.repeat(width - 2) + '┘';
+    const separator = '├' + '─'.repeat(width - 2) + '┤';
+    const emptyLine = '│' + ' '.repeat(width - 2) + '│';
+    const createLine = (text, align = 'left') => {
+        const contentWidth = width - 4;
+        let content = text.slice(0, contentWidth);
+        if (align === 'center') {
+            const padding = Math.floor((contentWidth - content.length) / 2);
+            content = ' '.repeat(padding) + content + ' '.repeat(contentWidth - padding - content.length);
+        }
+        else if (align === 'right') {
+            content = ' '.repeat(contentWidth - content.length) + content;
+        }
+        else {
+            content = content + ' '.repeat(contentWidth - content.length);
+        }
+        return '│ ' + content + ' │';
+    };
+    const createBox = (label, w, h) => {
+        const lines = [];
+        lines.push('┌' + '─'.repeat(w - 2) + '┐');
+        for (let i = 0; i < h - 2; i++) {
+            if (i === Math.floor((h - 2) / 2)) {
+                const padding = Math.floor((w - 4 - label.length) / 2);
+                const text = ' '.repeat(padding) + label + ' '.repeat(w - 4 - padding - label.length);
+                lines.push('│ ' + text + ' │');
+            }
+            else {
+                lines.push('│ ' + ' '.repeat(w - 4) + ' │');
+            }
+        }
+        lines.push('└' + '─'.repeat(w - 2) + '┘');
+        return lines;
+    };
+    let preview = [];
+    // Generate preview based on layout type
+    preview.push(topBorder);
+    switch (layout_type) {
+        case 'header-footer': {
+            // Header
+            const header = components.find(c => c.type === 'header' || c.position === 'top');
+            if (header) {
+                preview.push(createLine(header.label || 'Header', 'left'));
+                preview.push(separator);
+            }
+            // Main content
+            const mainComponents = components.filter(c => c.type !== 'header' && c.type !== 'footer' && c.position !== 'top' && c.position !== 'bottom');
+            preview.push(emptyLine);
+            mainComponents.forEach(comp => {
+                const label = comp.label || comp.type.toUpperCase();
+                if (comp.type === 'button') {
+                    preview.push(createLine(`  [${label}]`, 'center'));
+                }
+                else if (comp.type === 'input') {
+                    preview.push(createLine(`  ${label}: [____________]`, 'left'));
+                }
+                else if (comp.type === 'card') {
+                    preview.push(createLine(`  ┌─ ${label} ─────────────┐`, 'left'));
+                    preview.push(createLine(`  │ Content here...      │`, 'left'));
+                    preview.push(createLine(`  └──────────────────────┘`, 'left'));
+                }
+                else {
+                    preview.push(createLine(`  ${label}`, 'left'));
+                }
+            });
+            preview.push(emptyLine);
+            // Footer
+            const footer = components.find(c => c.type === 'footer' || c.position === 'bottom');
+            if (footer) {
+                preview.push(separator);
+                preview.push(createLine(footer.label || 'Footer', 'center'));
+            }
+            break;
+        }
+        case 'sidebar': {
+            // Header
+            const header = components.find(c => c.type === 'header' || c.position === 'top');
+            if (header) {
+                preview.push(createLine(header.label || 'Header', 'left'));
+                preview.push(separator);
+            }
+            // Sidebar + Content
+            const sidebarWidth = Math.floor(width * 0.25);
+            const contentWidth = width - sidebarWidth - 5;
+            const sidebar = components.find(c => c.type === 'sidebar' || c.position === 'left');
+            const mainComponents = components.filter(c => c.type !== 'header' && c.type !== 'footer' && c.type !== 'sidebar' &&
+                c.position !== 'top' && c.position !== 'bottom' && c.position !== 'left');
+            preview.push('│ ┌' + '─'.repeat(sidebarWidth - 2) + '┐' + ' '.repeat(contentWidth - sidebarWidth + 3) + '│');
+            preview.push('│ │' + (sidebar?.label || 'Nav').padEnd(sidebarWidth - 2) + '│  Content Area' + ' '.repeat(contentWidth - 15) + '│');
+            const navItems = mainComponents.slice(0, 3);
+            navItems.forEach((item, idx) => {
+                const navLabel = `${item.label || item.type}`.slice(0, sidebarWidth - 4);
+                const contentLabel = idx === 0 ? `┌─ ${mainComponents[0]?.label || 'Main'} ─┐` : '';
+                preview.push('│ │ ' + navLabel.padEnd(sidebarWidth - 3) + '│  ' + contentLabel.padEnd(contentWidth - 3) + '│');
+            });
+            preview.push('│ └' + '─'.repeat(sidebarWidth - 2) + '┘' + ' '.repeat(contentWidth - sidebarWidth + 3) + '│');
+            // Footer
+            const footer = components.find(c => c.type === 'footer' || c.position === 'bottom');
+            if (footer) {
+                preview.push(separator);
+                preview.push(createLine(footer.label || 'Footer', 'center'));
+            }
+            break;
+        }
+        case 'grid': {
+            preview.push(createLine('Grid Layout', 'center'));
+            preview.push(separator);
+            const gridComponents = components.filter(c => c.type !== 'header' && c.type !== 'footer');
+            const cols = Math.ceil(Math.sqrt(gridComponents.length));
+            const cellWidth = Math.floor((width - 4) / cols) - 2;
+            for (let i = 0; i < gridComponents.length; i += cols) {
+                const row = gridComponents.slice(i, i + cols);
+                preview.push('│ ' + row.map(c => {
+                    const label = (c.label || c.type).slice(0, cellWidth - 2);
+                    return '┌' + label.padEnd(cellWidth - 2, '─') + '┐';
+                }).join(' ') + ' '.repeat(width - 4 - row.length * (cellWidth + 1)) + ' │');
+                preview.push('│ ' + row.map(c => '│' + ' '.repeat(cellWidth - 2) + '│').join(' ') + ' '.repeat(width - 4 - row.length * (cellWidth + 1)) + ' │');
+                preview.push('│ ' + row.map(c => '└' + '─'.repeat(cellWidth - 2) + '┘').join(' ') + ' '.repeat(width - 4 - row.length * (cellWidth + 1)) + ' │');
+            }
+            break;
+        }
+        case 'centered': {
+            const main = components[0];
+            preview.push(emptyLine);
+            preview.push(emptyLine);
+            preview.push(createLine(main?.label || 'Main Content', 'center'));
+            components.slice(1).forEach(comp => {
+                if (comp.type === 'button') {
+                    preview.push(createLine(`[${comp.label || 'Button'}]`, 'center'));
+                }
+                else if (comp.type === 'input') {
+                    preview.push(createLine(`${comp.label || 'Input'}: [____________]`, 'center'));
+                }
+            });
+            preview.push(emptyLine);
+            preview.push(emptyLine);
+            break;
+        }
+        case 'split': {
+            const leftWidth = Math.floor((width - 5) / 2);
+            const rightWidth = width - leftWidth - 5;
+            preview.push('│ ┌' + '─'.repeat(leftWidth) + '┐ ┌' + '─'.repeat(rightWidth) + '┐ │');
+            const left = components.find(c => c.position === 'left') || components[0];
+            const right = components.find(c => c.position === 'right') || components[1];
+            preview.push('│ │' + (left?.label || 'Left').padEnd(leftWidth) + '│ │' + (right?.label || 'Right').padEnd(rightWidth) + '│ │');
+            for (let i = 0; i < 5; i++) {
+                preview.push('│ │' + ' '.repeat(leftWidth) + '│ │' + ' '.repeat(rightWidth) + '│ │');
+            }
+            preview.push('│ └' + '─'.repeat(leftWidth) + '┘ └' + '─'.repeat(rightWidth) + '┘ │');
+            break;
+        }
+    }
+    preview.push(bottomBorder);
+    // Mobile view if responsive
+    let mobilePreview = '';
+    if (responsive) {
+        const mobileWidth = 30;
+        const mobileTop = '┌' + '─'.repeat(mobileWidth - 2) + '┐';
+        const mobileBottom = '└' + '─'.repeat(mobileWidth - 2) + '┘';
+        mobilePreview = '\n\n📱 Mobile View:\n';
+        mobilePreview += mobileTop + '\n';
+        components.forEach(comp => {
+            const label = (comp.label || comp.type).slice(0, mobileWidth - 4);
+            mobilePreview += '│ ' + label.padEnd(mobileWidth - 4) + ' │\n';
+        });
+        mobilePreview += mobileBottom;
+    }
+    const result = {
+        page_name,
+        layout_type,
+        ascii_preview: preview.join('\n'),
+        mobile_preview: responsive ? mobilePreview : null,
+        components_count: components.length,
+        message: '✅ 이 레이아웃으로 진행하시겠습니까? 승인하시면 코드 생성을 시작합니다.',
+        action: 'preview_ui_ascii',
+        status: 'awaiting_confirmation'
+    };
+    return {
+        content: [{
+                type: 'text',
+                text: `🎨 UI Preview: ${page_name}\n\n${preview.join('\n')}${mobilePreview}\n\n${result.message}`
+            }]
+    };
+}

package/mcp/dist/types/tool.js

@@ -0,0 +1,2 @@
+// Common MCP tool type definitions (v1.3)
+export {};

package/mcp/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "vide-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for vide framework (based on hi-ai)",
+  "private": true,
+  "main": "dist/index.js",
+  "module": "./src/index.ts",
+  "type": "module",
+  "scripts": {
+    "dev": "npm run build && node dist/index.js",
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "assistant",
+    "development-tools",
+    "code-analysis",
+    "typescript",
+    "javascript",
+    "python",
+    "semantic-analysis",
+    "code-quality",
+    "memory-management",
+    "project-planning",
+    "claude",
+    "anthropic"
+  ],
+  "author": "Su",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@smithery/sdk": "^1.6.8",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/glob": "^8.1.0",
+    "better-sqlite3": "^12.4.1",
+    "chalk": "^5.3.0",
+    "glob": "^11.0.3",
+    "puppeteer-core": "^22.15.0",
+    "ts-morph": "^26.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@vitest/ui": "^4.0.9",
+    "typescript": "^5.5.4",
+    "vitest": "^4.0.9"
+  }
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@su-record/vibe",
+  "version": "0.1.0",
+  "description": "Vibe - SPEC-driven AI coding framework with MCP integration",
+  "main": "cli/index.js",
+  "bin": {
+    "vibe": "./bin/vibe"
+  },
+  "scripts": {
+    "build": "cd mcp && npm install && npm run build",
+    "postinstall": "node scripts/install-mcp.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "ai",
+    "coding",
+    "spec-driven",
+    "claude",
+    "mcp",
+    "framework",
+    "spec-kit",
+    "requirements",
+    "user-story"
+  ],
+  "author": "grove",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/su-record/vibe.git"
+  },
+  "homepage": "https://github.com/su-record/vibe#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "files": [
+    "bin/",
+    "cli/",
+    "agents/",
+    "skills/",
+    "templates/",
+    "scripts/",
+    "mcp/dist/",
+    "mcp/package.json",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/scripts/install-mcp.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+console.log('🔧 vibe MCP 서버 설치 중...\n');
+
+// MCP 서버 경로 (npm 글로벌 설치 위치)
+const mcpIndexPath = path.join(__dirname, '../mcp/dist/index.js');
+
+// 상대 경로로 확인 (로컬 개발 시)
+if (!fs.existsSync(mcpIndexPath)) {
+  console.log('⚠️  MCP 서버를 찾을 수 없습니다.');
+  console.log('   경로:', mcpIndexPath);
+  console.log('   npm install을 다시 실행해주세요.\n');
+  process.exit(1);
+}
+
+console.log('📍 MCP 서버 경로:', mcpIndexPath);
+
+try {
+  // Claude Code에 MCP 서버 등록
+  const command = `claude mcp add vibe node "${mcpIndexPath}"`;
+  console.log('📝 실행:', command);
+  console.log('');
+
+  execSync(command, { stdio: 'inherit' });
+
+  console.log('\n✅ vibe MCP 서버 등록 완료!');
+  console.log('');
+  console.log('사용 가능한 도구:');
+  console.log('  - 38개 MCP 도구 (@su-record/hi-ai 기반)');
+  console.log('  - 코드 분석, 품질 검증, UI 미리보기 등');
+  console.log('');
+  console.log('다음 명령어로 확인:');
+  console.log('  claude mcp list');
+  console.log('');
+
+} catch (error) {
+  console.error('❌ MCP 서버 등록 실패');
+  console.error('');
+  console.error('수동 등록 방법:');
+  console.error(`  claude mcp add vibe node "${mcpIndexPath}"`);
+  console.error('');
+  console.error('에러:', error.message);
+  process.exit(1);
+}