@su-record/vibe 0.1.0

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

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

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

@@ -0,0 +1,146 @@
+/**
+ * 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');
+    });
+});

package/mcp/dist/index.js

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+// Import all tool definitions and handlers
+import { getCurrentTimeDefinition, getCurrentTime } from './tools/time/getCurrentTime.js';
+// Semantic code analysis tools (Serena-inspired)
+import { findSymbolDefinition, findSymbol } from './tools/semantic/findSymbol.js';
+import { findReferencesDefinition, findReferences } from './tools/semantic/findReferences.js';
+import { createThinkingChainDefinition, createThinkingChain } from './tools/thinking/createThinkingChain.js';
+import { analyzeProblemDefinition, analyzeProblem } from './tools/thinking/analyzeProblem.js';
+import { stepByStepAnalysisDefinition, stepByStepAnalysis } from './tools/thinking/stepByStepAnalysis.js';
+import { breakDownProblemDefinition, breakDownProblem } from './tools/thinking/breakDownProblem.js';
+import { thinkAloudProcessDefinition, thinkAloudProcess } from './tools/thinking/thinkAloudProcess.js';
+import { formatAsPlanDefinition, formatAsPlan } from './tools/thinking/formatAsPlan.js';
+import { monitorConsoleLogsDefinition, monitorConsoleLogs } from './tools/browser/monitorConsoleLogs.js';
+import { inspectNetworkRequestsDefinition, inspectNetworkRequests } from './tools/browser/inspectNetworkRequests.js';
+import { saveMemoryDefinition, saveMemory } from './tools/memory/saveMemory.js';
+import { recallMemoryDefinition, recallMemory } from './tools/memory/recallMemory.js';
+import { listMemoriesDefinition, listMemories } from './tools/memory/listMemories.js';
+import { deleteMemoryDefinition, deleteMemory } from './tools/memory/deleteMemory.js';
+import { searchMemoriesDefinition, searchMemoriesHandler } from './tools/memory/searchMemories.js';
+import { updateMemoryDefinition, updateMemory } from './tools/memory/updateMemory.js';
+import { autoSaveContextDefinition, autoSaveContext } from './tools/memory/autoSaveContext.js';
+import { restoreSessionContextDefinition, restoreSessionContext } from './tools/memory/restoreSessionContext.js';
+import { prioritizeMemoryDefinition, prioritizeMemory } from './tools/memory/prioritizeMemory.js';
+import { startSessionDefinition, startSession } from './tools/memory/startSession.js';
+import { getCodingGuideDefinition, getCodingGuide } from './tools/convention/getCodingGuide.js';
+import { applyQualityRulesDefinition, applyQualityRules } from './tools/convention/applyQualityRules.js';
+import { validateCodeQualityDefinition, validateCodeQuality } from './tools/convention/validateCodeQuality.js';
+import { analyzeComplexityDefinition, analyzeComplexity } from './tools/convention/analyzeComplexity.js';
+import { checkCouplingCohesionDefinition, checkCouplingCohesion } from './tools/convention/checkCouplingCohesion.js';
+import { suggestImprovementsDefinition, suggestImprovements } from './tools/convention/suggestImprovements.js';
+import { generatePrdDefinition, generatePrd } from './tools/planning/generatePrd.js';
+import { createUserStoriesDefinition, createUserStories } from './tools/planning/createUserStories.js';
+import { analyzeRequirementsDefinition, analyzeRequirements } from './tools/planning/analyzeRequirements.js';
+import { featureRoadmapDefinition, featureRoadmap } from './tools/planning/featureRoadmap.js';
+import { enhancePromptDefinition, enhancePrompt } from './tools/prompt/enhancePrompt.js';
+import { analyzePromptDefinition, analyzePrompt } from './tools/prompt/analyzePrompt.js';
+import { previewUiAsciiDefinition, previewUiAscii } from './tools/ui/previewUiAscii.js';
+// Collect all tool definitions
+const tools = [
+    // Time Utility Tools
+    getCurrentTimeDefinition,
+    // Semantic Code Analysis Tools (Serena-inspired)
+    findSymbolDefinition,
+    findReferencesDefinition,
+    // Sequential Thinking Tools  
+    createThinkingChainDefinition,
+    analyzeProblemDefinition,
+    stepByStepAnalysisDefinition,
+    breakDownProblemDefinition,
+    thinkAloudProcessDefinition,
+    formatAsPlanDefinition,
+    // Browser Development Tools
+    monitorConsoleLogsDefinition,
+    inspectNetworkRequestsDefinition,
+    // Memory Management Tools
+    saveMemoryDefinition,
+    recallMemoryDefinition,
+    listMemoriesDefinition,
+    deleteMemoryDefinition,
+    searchMemoriesDefinition,
+    updateMemoryDefinition,
+    autoSaveContextDefinition,
+    restoreSessionContextDefinition,
+    prioritizeMemoryDefinition,
+    startSessionDefinition,
+    // Convention Tools
+    getCodingGuideDefinition,
+    applyQualityRulesDefinition,
+    validateCodeQualityDefinition,
+    analyzeComplexityDefinition,
+    checkCouplingCohesionDefinition,
+    suggestImprovementsDefinition,
+    // Planning Tools
+    generatePrdDefinition,
+    createUserStoriesDefinition,
+    analyzeRequirementsDefinition,
+    featureRoadmapDefinition,
+    // Prompt Enhancement Tools
+    enhancePromptDefinition,
+    analyzePromptDefinition,
+    // UI Preview Tools
+    previewUiAsciiDefinition
+];
+function createServer() {
+    const server = new Server({
+        name: 'Hi-AI',
+        version: '1.3.0',
+    }, {
+        capabilities: {
+            tools: {},
+            prompts: {},
+            resources: {},
+        },
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return { tools };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+        const { name, arguments: args } = request.params;
+        try {
+            switch (name) {
+                // Time Utility Tools
+                case 'get_current_time':
+                    return await getCurrentTime(args);
+                // Semantic Code Analysis Tools
+                case 'find_symbol':
+                    return await findSymbol(args);
+                case 'find_references':
+                    return await findReferences(args);
+                // Sequential Thinking Tools
+                case 'create_thinking_chain':
+                    return await createThinkingChain(args);
+                case 'analyze_problem':
+                    return await analyzeProblem(args);
+                case 'step_by_step_analysis':
+                    return await stepByStepAnalysis(args);
+                case 'break_down_problem':
+                    return await breakDownProblem(args);
+                case 'think_aloud_process':
+                    return await thinkAloudProcess(args);
+                case 'format_as_plan':
+                    return await formatAsPlan(args);
+                // Browser Development Tools
+                case 'monitor_console_logs':
+                    return await monitorConsoleLogs(args);
+                case 'inspect_network_requests':
+                    return await inspectNetworkRequests(args);
+                // Memory Management Tools
+                case 'save_memory':
+                    return await saveMemory(args);
+                case 'recall_memory':
+                    return await recallMemory(args);
+                case 'list_memories':
+                    return await listMemories(args);
+                case 'delete_memory':
+                    return await deleteMemory(args);
+                case 'search_memories':
+                    return await searchMemoriesHandler(args);
+                case 'update_memory':
+                    return await updateMemory(args);
+                case 'auto_save_context':
+                    return await autoSaveContext(args);
+                case 'restore_session_context':
+                    return await restoreSessionContext(args);
+                case 'prioritize_memory':
+                    return await prioritizeMemory(args);
+                case 'start_session':
+                    return await startSession(args);
+                // Convention Tools
+                case 'get_coding_guide':
+                    return await getCodingGuide(args);
+                case 'apply_quality_rules':
+                    return await applyQualityRules(args);
+                case 'validate_code_quality':
+                    return await validateCodeQuality(args);
+                case 'analyze_complexity':
+                    return await analyzeComplexity(args);
+                case 'check_coupling_cohesion':
+                    return await checkCouplingCohesion(args);
+                case 'suggest_improvements':
+                    return await suggestImprovements(args);
+                // Planning Tools
+                case 'generate_prd':
+                    return await generatePrd(args);
+                case 'create_user_stories':
+                    return await createUserStories(args);
+                case 'analyze_requirements':
+                    return await analyzeRequirements(args);
+                case 'feature_roadmap':
+                    return await featureRoadmap(args);
+                // Prompt Enhancement Tools
+                case 'enhance_prompt':
+                    return await enhancePrompt(args);
+                case 'analyze_prompt':
+                    return await analyzePrompt(args);
+                // UI Preview Tools
+                case 'preview_ui_ascii':
+                    return await previewUiAscii(args);
+                default:
+                    throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+            }
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.InternalError, `Error executing tool: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    });
+    return server;
+}
+// Default export for Smithery platform
+export default function ({ sessionId, config }) {
+    // Return the configured server instance
+    return createServer();
+}
+async function main() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    // Handle process termination gracefully
+    process.on('SIGINT', async () => {
+        await server.close();
+        process.exit(0);
+    });
+    process.on('SIGTERM', async () => {
+        await server.close();
+        process.exit(0);
+    });
+    // Handle EPIPE errors that occur with sidecar proxy
+    process.on('uncaughtException', (error) => {
+        if (error.message && error.message.includes('EPIPE')) {
+            // Gracefully handle EPIPE errors
+            console.error('Connection closed by client');
+            return;
+        }
+        console.error('Uncaught exception:', error);
+        process.exit(1);
+    });
+    process.on('unhandledRejection', (reason, promise) => {
+        console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+    });
+    await server.connect(transport);
+}
+// Only run main when not being imported by Smithery
+if (process.argv[1]?.includes('hi-ai') || process.argv[1]?.endsWith('index.js')) {
+    main().catch((error) => {
+        console.error('Server initialization failed:', error);
+        process.exit(1);
+    });
+}