@su-record/vibe 0.1.2 → 0.1.4

package/README.md

@@ -29,17 +29,16 @@ Transform natural language requirements into production-ready code through struc
 npm install -g @su-record/vibe
 ```
 
-This automatically:
-- Installs the Vibe CLI
-- Registers the MCP server with 38 development tools
-- Enables slash commands for Claude Code
+This installs:
+- Vibe CLI commands
+- @su-record/hi-ai MCP server (38 development tools)
 
 ---
 
 ## Quick Start
 
 ```bash
-# Initialize project
+# Initialize project (registers MCP server for this project)
 vibe init
 
 # Create specification through guided Q&A
@@ -145,12 +144,20 @@ Vibe includes 38 MCP tools across multiple categories:
 - `recall_memory` - Retrieve stored information
 - `auto_save_context` - Automatic context checkpointing
 
+**MCP Server Registration:**
+
+The MCP server is automatically registered when you run `vibe init` in your project. This registers the server **locally for your project only**, not globally.
+
 **Verify MCP server:**
 ```bash
+# Run this in your project directory
 claude mcp list
-# vibe: node /path/to/vibe/mcp/dist/index.js - ✓ Connected
+# Expected output:
+# vibe: node /path/to/@su-record/vibe/node_modules/@su-record/hi-ai/dist/index.js - ✓ Connected
 ```
 
+**Important:** Each project that uses Vibe must run `vibe init` to register the MCP server for that specific project.
+
 ---
 
 ## Configuration

package/bin/vibe

@@ -92,6 +92,20 @@ function init() {
     return;
   }
 
+  // MCP 서버 등록 먼저 체크 및 실행
+  console.log('🔧 MCP 서버 확인 중...\n');
+  try {
+    const { execSync } = require('child_process');
+
+    // MCP 서버 등록 스크립트 실행
+    const installScriptPath = path.join(__dirname, '../scripts/install-mcp.js');
+    execSync(`node "${installScriptPath}"`, { stdio: 'inherit' });
+
+  } catch (error) {
+    console.log('\n⚠️  MCP 서버 등록 중 오류가 발생했습니다.');
+    console.log('   계속 진행합니다...\n');
+  }
+
   // 폴더 생성
   fs.mkdirSync(vibeDir);
   fs.mkdirSync(path.join(vibeDir, 'specs'));
@@ -115,7 +129,7 @@ function init() {
     },
     mcp: {
       enabled: true,
-      servers: ['hi-ai', 'context-7']
+      servers: ['vibe']
     },
     quality: {
       strict: true,
@@ -135,11 +149,15 @@ function init() {
   ├── plans/            # 기술 계획들
   └── tasks/            # 작업 목록들
 
+MCP 서버:
+  ✓ vibe MCP 서버 등록 완료 (38개 도구)
+  확인: claude mcp list
+
 언어 변경:
   .vibe/config.json에서 "language"를 "en" 또는 "ko"로 변경
 
 다음 단계:
-  vibe story create "기능명"  - 새 기능 스토리 작성
+  vibe spec "기능명"  - 새 기능 SPEC 작성
   `);
 }
 

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "@su-record/vibe",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "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",
+    "build": "echo \"No build needed - using @su-record/hi-ai\"",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [
@@ -32,7 +31,9 @@
   "engines": {
     "node": ">=18.0.0"
   },
-  "dependencies": {},
+  "dependencies": {
+    "@su-record/hi-ai": "latest"
+  },
   "devDependencies": {},
   "files": [
     "bin/",
@@ -41,8 +42,6 @@
     "skills/",
     "templates/",
     "scripts/",
-    "mcp/dist/",
-    "mcp/package.json",
     "README.md",
     "LICENSE"
   ]

package/scripts/install-mcp.js

@@ -6,14 +6,23 @@ const fs = require('fs');
 
 console.log('🔧 vibe MCP 서버 설치 중...\n');
 
-// MCP 서버 경로 (npm 글로벌 설치 위치)
-const mcpIndexPath = path.join(__dirname, '../mcp/dist/index.js');
+// vibe 패키지의 실제 설치 경로 찾기
+// npm link인 경우: 로컬 개발 경로
+// npm install -g인 경우: 글로벌 설치 경로
+// path.dirname()을 사용해 크로스 플랫폼 호환 (Windows/Unix)
+const vibePackagePath = path.dirname(__dirname);
 
-// 상대 경로로 확인 (로컬 개발 시)
+// MCP 서버 경로 (hi-ai 패키지)
+// path.join()이 자동으로 OS별 경로 구분자 처리
+const mcpIndexPath = path.join(vibePackagePath, 'node_modules', '@su-record', 'hi-ai', 'dist', 'index.js');
+
+// hi-ai 설치 확인
 if (!fs.existsSync(mcpIndexPath)) {
-  console.log('⚠️  MCP 서버를 찾을 수 없습니다.');
+  console.log('⚠️  hi-ai MCP 서버를 찾을 수 없습니다.');
   console.log('   경로:', mcpIndexPath);
-  console.log('   npm install을 다시 실행해주세요.\n');
+  console.log('   npm install을 실행해주세요.\n');
+  console.log('   npm install');
+  console.log('');
   process.exit(1);
 }
 
@@ -38,11 +47,28 @@ try {
   console.log('');
 
 } catch (error) {
+  // stderr 출력 확인
+  const stderrOutput = error.stderr ? error.stderr.toString() : '';
+  const stdoutOutput = error.stdout ? error.stdout.toString() : '';
+  const fullOutput = error.message + stderrOutput + stdoutOutput;
+
+  // "already exists" 에러는 성공으로 간주
+  if (fullOutput.includes('already exists')) {
+    console.log('ℹ️  vibe MCP 서버가 이미 등록되어 있습니다.');
+    console.log('');
+    console.log('다음 명령어로 확인:');
+    console.log('  claude mcp list');
+    console.log('');
+    process.exit(0);
+  }
+
   console.error('❌ MCP 서버 등록 실패');
   console.error('');
   console.error('수동 등록 방법:');
   console.error(`  claude mcp add vibe node "${mcpIndexPath}"`);
   console.error('');
   console.error('에러:', error.message);
+  if (stderrOutput) console.error('stderr:', stderrOutput);
+  if (stdoutOutput) console.error('stdout:', stdoutOutput);
   process.exit(1);
 }

package/mcp/dist/__tests__/complexity.test.js

@@ -1,126 +0,0 @@
-import { describe, test, expect } from 'vitest';
-import { analyzeComplexity, analyzeComplexityDefinition } from '../tools/convention/analyzeComplexity.js';
-describe('Code Complexity Analysis', () => {
-    describe('analyzeComplexity', () => {
-        test('should analyze simple function with low complexity', async () => {
-            const simpleCode = `
-        function add(a, b) {
-          return a + b;
-        }
-      `;
-            const result = await analyzeComplexity({ code: simpleCode, metrics: 'all' });
-            const parsed = JSON.parse(result.content[0].text.replace('Complexity Analysis:\n', ''));
-            expect(parsed.status).toBe('success');
-            expect(parsed.results.cyclomaticComplexity).toBeDefined();
-            expect(parsed.results.cognitiveComplexity).toBeDefined();
-            expect(parsed.results.halsteadMetrics).toBeDefined();
-            expect(parsed.results.cyclomaticComplexity.status).toBe('pass');
-        });
-        test('should detect high cyclomatic complexity', async () => {
-            const complexCode = `
-        function complexFunction(x) {
-          if (x > 0) {
-            if (x < 10) {
-              for (let i = 0; i < x; i++) {
-                if (i % 2 === 0) {
-                  while (i < 5) {
-                    if (i === 3) {
-                      return i;
-                    }
-                    i++;
-                  }
-                }
-              }
-            }
-          }
-          return x;
-        }
-      `;
-            const result = await analyzeComplexity({ code: complexCode, metrics: 'all' });
-            const parsed = JSON.parse(result.content[0].text.replace('Complexity Analysis:\n', ''));
-            expect(parsed.results.cyclomaticComplexity.value).toBeGreaterThan(5);
-            expect(parsed.issues.length).toBeGreaterThan(0);
-        });
-        test('should calculate AST-based complexity', async () => {
-            const code = `
-        function test() {
-          if (true) return 1;
-          for (let i = 0; i < 10; i++) {
-            console.log(i);
-          }
-        }
-      `;
-            const result = await analyzeComplexity({ code, metrics: 'cyclomatic' });
-            const parsed = JSON.parse(result.content[0].text.replace('Complexity Analysis:\n', ''));
-            expect(parsed.results.astCyclomaticComplexity).toBeDefined();
-            expect(parsed.results.astCyclomaticComplexity.value).toBeGreaterThan(1);
-        });
-        test('should calculate cognitive complexity with nesting', async () => {
-            const code = `
-        function nested() {
-          if (a) {
-            if (b) {
-              if (c) {
-                return true;
-              }
-            }
-          }
-        }
-      `;
-            const result = await analyzeComplexity({ code, metrics: 'cognitive' });
-            const parsed = JSON.parse(result.content[0].text.replace('Complexity Analysis:\n', ''));
-            expect(parsed.results.cognitiveComplexity.value).toBeGreaterThan(0);
-        });
-        test('should calculate Halstead metrics', async () => {
-            const code = `
-        function calculate(x, y) {
-          const sum = x + y;
-          const product = x * y;
-          return sum + product;
-        }
-      `;
-            const result = await analyzeComplexity({ code, metrics: 'halstead' });
-            const parsed = JSON.parse(result.content[0].text.replace('Complexity Analysis:\n', ''));
-            expect(parsed.results.halsteadMetrics).toBeDefined();
-            expect(parsed.results.halsteadMetrics.vocabulary).toBeGreaterThan(0);
-            expect(parsed.results.halsteadMetrics.difficulty).toBeGreaterThan(0);
-        });
-        test('should provide recommendations for complex code', async () => {
-            const veryComplexCode = `
-        function veryComplex(a, b, c, d, e) {
-          if (a) {
-            if (b) {
-              for (let i = 0; i < 10; i++) {
-                if (c) {
-                  while (d) {
-                    if (e) {
-                      return true;
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return false;
-        }
-      `;
-            const result = await analyzeComplexity({ code: veryComplexCode, metrics: 'all' });
-            const parsed = JSON.parse(result.content[0].text.replace('Complexity Analysis:\n', ''));
-            expect(parsed.recommendations).toBeDefined();
-            expect(parsed.recommendations.length).toBeGreaterThan(0);
-            expect(parsed.overallScore).toBeLessThan(100);
-        });
-    });
-    describe('Tool Definition', () => {
-        test('should have correct definition', () => {
-            expect(analyzeComplexityDefinition.name).toBe('analyze_complexity');
-            expect(analyzeComplexityDefinition.description).toContain('IMPORTANT');
-            expect(analyzeComplexityDefinition.inputSchema.required).toContain('code');
-        });
-        test('should include keyword triggers', () => {
-            const desc = analyzeComplexityDefinition.description;
-            expect(desc).toContain('복잡도');
-            expect(desc).toContain('complexity');
-        });
-    });
-});

package/mcp/dist/__tests__/memory.test.js

@@ -1,120 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from 'vitest';
-import { saveMemory, saveMemoryDefinition } from '../tools/memory/saveMemory.js';
-import { recallMemory } from '../tools/memory/recallMemory.js';
-import { listMemories } from '../tools/memory/listMemories.js';
-import { deleteMemory } from '../tools/memory/deleteMemory.js';
-import { memoryDB } from '../tools/memory/database.js';
-import { clearAllMemories } from '../tools/memory/memorySQLite.js';
-import { promises as fs } from 'fs';
-import path from 'path';
-const TEST_MEMORY_DIR = path.join(process.cwd(), 'memories');
-describe('Memory Management Tools', () => {
-    beforeEach(async () => {
-        // Ensure fresh database for each test
-        try {
-            // Close existing connection if any
-            memoryDB.close();
-        }
-        catch (error) {
-            // Ignore
-        }
-        // Clean up test files
-        try {
-            await fs.rm(TEST_MEMORY_DIR, { recursive: true, force: true });
-        }
-        catch (error) {
-            // Ignore
-        }
-        // Clear all memories (this will recreate DB if needed)
-        try {
-            clearAllMemories();
-        }
-        catch (error) {
-            // Database might not exist yet, will be created on first use
-        }
-    });
-    afterEach(async () => {
-        // Close database connection
-        try {
-            memoryDB.close();
-        }
-        catch (error) {
-            // Ignore
-        }
-    });
-    describe('saveMemory', () => {
-        test('should save memory successfully', async () => {
-            const result = await saveMemory({
-                key: 'test-key',
-                value: 'test-value',
-                category: 'project'
-            });
-            expect(result.content[0].text).toContain('success');
-            expect(result.content[0].text).toContain('test-key');
-        });
-        test('should create memory database if not exists', async () => {
-            await saveMemory({ key: 'test-key', value: 'test-value' });
-            // Check if database file exists
-            const dbPath = path.join(TEST_MEMORY_DIR, 'memories.db');
-            const dbExists = await fs.access(dbPath).then(() => true).catch(() => false);
-            expect(dbExists).toBe(true);
-        });
-    });
-    describe('recallMemory', () => {
-        test('should recall saved memory', async () => {
-            await saveMemory({ key: 'recall-test', value: 'recall-value' });
-            const result = await recallMemory({ key: 'recall-test' });
-            const parsedResult = JSON.parse(result.content[0].text.replace('Memory recalled:\n', ''));
-            expect(parsedResult.value).toBe('recall-value');
-            expect(parsedResult.key).toBe('recall-test');
-        });
-        test('should return not found for non-existent key', async () => {
-            const result = await recallMemory({ key: 'non-existent' });
-            expect(result.content[0].text).toContain('not found');
-        });
-    });
-    describe('listMemories', () => {
-        test('should list all memories', async () => {
-            await saveMemory({ key: 'key1', value: 'value1', category: 'project' });
-            await saveMemory({ key: 'key2', value: 'value2', category: 'code' });
-            const result = await listMemories({ summary: false });
-            const parsed = JSON.parse(result.content[0].text.replace('Memory list:\n', ''));
-            expect(parsed.memories.length).toBe(2);
-            expect(parsed.total).toBe(2);
-        });
-        test('should filter memories by category', async () => {
-            await saveMemory({ key: 'project1', value: 'val1', category: 'project' });
-            await saveMemory({ key: 'code1', value: 'val2', category: 'code' });
-            const result = await listMemories({ category: 'project', summary: false });
-            const parsed = JSON.parse(result.content[0].text.replace('Memory list:\n', ''));
-            expect(parsed.total).toBe(1);
-            expect(parsed.memories[0].key).toBe('project1');
-        });
-        test('should return empty array when no memories exist', async () => {
-            const result = await listMemories({ summary: false });
-            const parsed = JSON.parse(result.content[0].text.replace('Memory list:\n', ''));
-            expect(parsed.memories).toEqual([]);
-            expect(parsed.total).toBe(0);
-        });
-    });
-    describe('deleteMemory', () => {
-        test('should delete existing memory', async () => {
-            await saveMemory({ key: 'delete-me', value: 'temporary' });
-            const deleteResult = await deleteMemory({ key: 'delete-me' });
-            expect(deleteResult.content[0].text).toContain('success');
-            const recallResult = await recallMemory({ key: 'delete-me' });
-            expect(recallResult.content[0].text).toContain('not found');
-        });
-    });
-    describe('Tool Definition', () => {
-        test('should have correct structure', () => {
-            expect(saveMemoryDefinition.name).toBe('save_memory');
-            expect(saveMemoryDefinition.description).toContain('IMPORTANT');
-            expect(saveMemoryDefinition.inputSchema.required).toContain('key');
-        });
-        test('should include keyword triggers', () => {
-            expect(saveMemoryDefinition.description).toContain('기억해');
-            expect(saveMemoryDefinition.description).toContain('remember');
-        });
-    });
-});

package/mcp/dist/__tests__/python-dart-complexity.test.js

@@ -1,146 +0,0 @@
-/**
- * Tests for Python and Dart/Flutter code complexity analysis
- */
-import { describe, it, expect } from 'vitest';
-import { detectLanguage } from '../tools/convention/languageDetector.js';
-import { calculatePythonComplexity, calculatePythonCognitiveComplexity } from '../tools/convention/pythonComplexity.js';
-import { calculateDartComplexity, calculateDartCognitiveComplexity } from '../tools/convention/dartComplexity.js';
-import { analyzeComplexity } from '../tools/convention/analyzeComplexity.js';
-describe('Language Detection', () => {
-    it('should detect Python code', () => {
-        const pythonCode = `
-def calculate_sum(numbers):
-    total = 0
-    for num in numbers:
-        total += num
-    return total
-`;
-        expect(detectLanguage(pythonCode)).toBe('python');
-    });
-    it('should detect Dart/Flutter code', () => {
-        const dartCode = `
-class MyWidget extends StatelessWidget {
-  @override
-  Widget build(BuildContext context) {
-    return Container(
-      child: Text('Hello'),
-    );
-  }
-}
-`;
-        expect(detectLanguage(dartCode)).toBe('dart');
-    });
-    it('should detect TypeScript code', () => {
-        const tsCode = `
-interface User {
-  name: string;
-  age: number;
-}
-
-function greet(user: User): void {
-  console.log(\`Hello, \${user.name}\`);
-}
-`;
-        expect(detectLanguage(tsCode)).toBe('typescript');
-    });
-});
-describe('Python Complexity Analysis', () => {
-    it('should calculate Python cyclomatic complexity', () => {
-        const pythonCode = `
-def complex_function(x, y, z):
-    if x > 0:
-        if y > 0:
-            return x + y
-        elif y < 0:
-            return x - y
-    elif z > 0:
-        for i in range(10):
-            if i % 2 == 0:
-                print(i)
-    return 0
-`;
-        const result = calculatePythonComplexity(pythonCode);
-        expect(result.value).toBeGreaterThan(5);
-        expect(result.status).toBeDefined();
-    });
-    it('should calculate Python cognitive complexity', () => {
-        const pythonCode = `
-def nested_function(items):
-    for item in items:
-        if item > 0:
-            if item % 2 == 0:
-                print("Even positive")
-    return items
-`;
-        const result = calculatePythonCognitiveComplexity(pythonCode);
-        expect(result.value).toBeGreaterThan(0);
-    });
-});
-describe('Dart Complexity Analysis', () => {
-    it('should calculate Dart cyclomatic complexity', () => {
-        const dartCode = `
-Widget buildWidget(bool condition) {
-  if (condition) {
-    return Text('Yes');
-  } else {
-    return Text('No');
-  }
-}
-`;
-        const result = calculateDartComplexity(dartCode);
-        expect(result.value).toBeGreaterThan(1);
-    });
-    it('should calculate Dart cognitive complexity', () => {
-        const dartCode = `
-class MyWidget extends StatelessWidget {
-  @override
-  Widget build(BuildContext context) {
-    return condition1
-      ? Text('A')
-      : condition2
-        ? Text('B')
-        : Text('C');
-  }
-}
-`;
-        const result = calculateDartCognitiveComplexity(dartCode);
-        expect(result.value).toBeGreaterThanOrEqual(0); // Ternary operators may not be counted
-    });
-});
-describe('Integrated Complexity Analysis', () => {
-    it('should analyze Python code with auto-detection', async () => {
-        const pythonCode = `
-def fibonacci(n):
-    if n <= 1:
-        return n
-    return fibonacci(n-1) + fibonacci(n-2)
-`;
-        const result = await analyzeComplexity({ code: pythonCode });
-        expect(result.content[0].text).toContain('Python');
-        expect(result.content[0].text).toContain('cyclomaticComplexity');
-    });
-    it('should analyze Dart code with auto-detection', async () => {
-        const dartCode = `
-class Counter extends StatefulWidget {
-  @override
-  _CounterState createState() => _CounterState();
-}
-`;
-        const result = await analyzeComplexity({ code: dartCode });
-        expect(result.content[0].text).toContain('Dart');
-    });
-    it('should analyze TypeScript code', async () => {
-        const tsCode = `
-function complexFunc(a: number, b: number): number {
-  if (a > b) {
-    return a;
-  } else if (a < b) {
-    return b;
-  }
-  return 0;
-}
-`;
-        const result = await analyzeComplexity({ code: tsCode });
-        expect(result.content[0].text).toContain('TypeScript');
-    });
-});