@su-record/vibe 0.1.0

package/mcp/dist/tools/semantic/findReferences.js

@@ -0,0 +1,195 @@
+// Semantic code analysis tool - Find References (v1.3)
+// With ProjectCache for 25x performance improvement
+import { Node } from 'ts-morph';
+import * as path from 'path';
+import { ProjectCache } from '../../lib/ProjectCache.js';
+import { readFile } from 'fs/promises';
+export const findReferencesDefinition = {
+    name: 'find_references',
+    description: '어디서 쓰|참조|사용처|find usage|references|where used - Find symbol references',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            symbolName: { type: 'string', description: 'Name of the symbol to find references for' },
+            filePath: { type: 'string', description: 'File path where the symbol is defined' },
+            line: { type: 'number', description: 'Line number of the symbol definition' },
+            projectPath: { type: 'string', description: 'Project directory path' }
+        },
+        required: ['symbolName', 'projectPath']
+    },
+    annotations: {
+        title: 'Find References',
+        audience: ['user', 'assistant']
+    }
+};
+export async function findReferences(args) {
+    const { symbolName, filePath, line, projectPath } = args;
+    try {
+        // Use cached project for performance
+        const projectCache = ProjectCache.getInstance();
+        const project = projectCache.getOrCreate(projectPath);
+        const allReferences = [];
+        // Check for Python files
+        const glob = await import('glob');
+        const pythonFiles = glob.globSync(path.join(projectPath, '**/*.py'), {
+            ignore: ['**/node_modules/**', '**/.git/**', '**/venv/**', '**/__pycache__/**']
+        });
+        // Parse Python files for references
+        for (const pyFile of pythonFiles) {
+            try {
+                const content = await readFile(pyFile, 'utf-8');
+                const lines = content.split('\n');
+                lines.forEach((line, index) => {
+                    if (line.includes(symbolName)) {
+                        const column = line.indexOf(symbolName);
+                        allReferences.push({
+                            filePath: pyFile,
+                            line: index + 1,
+                            column: column,
+                            text: line.trim().substring(0, 100),
+                            isDefinition: /^(def|class)\s/.test(line.trim())
+                        });
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`Error parsing Python file ${pyFile}:`, error);
+            }
+        }
+        // If specific file and line provided, use precise reference finding
+        if (filePath && line) {
+            const sourceFile = project.getSourceFile(filePath);
+            if (sourceFile) {
+                const position = sourceFile.compilerNode.getPositionOfLineAndCharacter(line - 1, 0);
+                const node = sourceFile.getDescendantAtPos(position);
+                if (node) {
+                    const symbol = node.getSymbol();
+                    if (symbol) {
+                        const references = project.getLanguageService().findReferencesAtPosition(sourceFile, position);
+                        if (references) {
+                            for (const ref of references) {
+                                for (const reference of ref.getReferences()) {
+                                    const refSourceFile = reference.getSourceFile();
+                                    const refNode = reference.getNode();
+                                    const start = refNode.getStartLinePos();
+                                    const pos = refSourceFile.getLineAndColumnAtPos(start);
+                                    allReferences.push({
+                                        filePath: refSourceFile.getFilePath(),
+                                        line: pos.line,
+                                        column: pos.column,
+                                        text: refNode.getParent()?.getText().substring(0, 100) || refNode.getText(),
+                                        isDefinition: reference.isDefinition() || false
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            // Fallback: search by name across all files
+            for (const sourceFile of project.getSourceFiles()) {
+                const filePath = sourceFile.getFilePath();
+                // Skip node_modules and other irrelevant paths
+                if (filePath.includes('node_modules') || filePath.includes('.git')) {
+                    continue;
+                }
+                // Find all identifiers matching the symbol name
+                sourceFile.forEachDescendant((node) => {
+                    if (Node.isIdentifier(node) && node.getText() === symbolName) {
+                        const start = node.getStartLinePos();
+                        const pos = sourceFile.getLineAndColumnAtPos(start);
+                        const parent = node.getParent();
+                        // Determine if this is a definition
+                        const isDefinition = isSymbolDefinition(node);
+                        allReferences.push({
+                            filePath: filePath,
+                            line: pos.line,
+                            column: pos.column,
+                            text: parent?.getText().substring(0, 100) || node.getText(),
+                            isDefinition
+                        });
+                    }
+                });
+            }
+        }
+        const definitions = allReferences.filter(r => r.isDefinition);
+        const usages = allReferences.filter(r => !r.isDefinition);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Found ${allReferences.length} references (${definitions.length} defs, ${usages.length} uses):\n${allReferences.slice(0, 20).map(r => `${r.isDefinition ? 'DEF' : 'USE'}: ${r.filePath}:${r.line}`).join('\n')}`
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Error finding references: ${error instanceof Error ? error.message : 'Unknown error'}`
+                }]
+        };
+    }
+}
+function isSymbolDefinition(node) {
+    const parent = node.getParent();
+    if (!parent)
+        return false;
+    // Check if this is a declaration
+    return Node.isFunctionDeclaration(parent) ||
+        Node.isClassDeclaration(parent) ||
+        Node.isInterfaceDeclaration(parent) ||
+        Node.isTypeAliasDeclaration(parent) ||
+        Node.isVariableDeclaration(parent) ||
+        Node.isMethodDeclaration(parent) ||
+        Node.isPropertyDeclaration(parent) ||
+        Node.isParameterDeclaration(parent);
+}
+function groupReferencesByFile(references) {
+    const grouped = {};
+    for (const ref of references) {
+        if (!grouped[ref.filePath]) {
+            grouped[ref.filePath] = [];
+        }
+        grouped[ref.filePath].push(ref);
+    }
+    // Sort references within each file by line number
+    for (const filePath in grouped) {
+        grouped[filePath].sort((a, b) => a.line - b.line);
+    }
+    return grouped;
+}
+function formatReferenceResults(result) {
+    let output = `# Reference Search Results\n\n`;
+    output += `**Symbol:** ${result.symbol}\n`;
+    output += `**Total References:** ${result.totalReferences}\n`;
+    output += `**Files:** ${result.filesCount}\n`;
+    output += `**Definitions:** ${result.definitions.length}\n`;
+    output += `**Usages:** ${result.usages.length}\n\n`;
+    if (result.totalReferences === 0) {
+        output += `No references found for "${result.symbol}".\n`;
+        return output;
+    }
+    // Show definitions first
+    if (result.definitions.length > 0) {
+        output += `## Definitions\n\n`;
+        result.definitions.forEach((def, index) => {
+            output += `${index + 1}. **${def.filePath}:${def.line}:${def.column}**\n`;
+            output += `   \`\`\`typescript\n   ${def.text}\n   \`\`\`\n\n`;
+        });
+    }
+    // Show usages grouped by file
+    output += `## Usages by File\n\n`;
+    for (const [filePath, refs] of Object.entries(result.references)) {
+        const usages = refs.filter(r => !r.isDefinition);
+        if (usages.length === 0)
+            continue;
+        output += `### ${filePath} (${usages.length} usages)\n\n`;
+        usages.forEach((ref) => {
+            output += `- **Line ${ref.line}:** \`${ref.text.substring(0, 60)}...\`\n`;
+        });
+        output += `\n`;
+    }
+    return output;
+}

package/mcp/dist/tools/semantic/findSymbol.js

@@ -0,0 +1,200 @@
+// Semantic code analysis tool - Find Symbol (v1.3)
+// With ProjectCache for 25x performance improvement
+import { Node } from 'ts-morph';
+import * as path from 'path';
+import { PythonParser } from '../../lib/PythonParser.js';
+import { ProjectCache } from '../../lib/ProjectCache.js';
+import { readFile } from 'fs/promises';
+export const findSymbolDefinition = {
+    name: 'find_symbol',
+    description: '함수 찾아|클래스 어디|변수 위치|find function|where is|locate - Find symbol definitions',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            symbolName: { type: 'string', description: 'Name of the symbol to find' },
+            projectPath: { type: 'string', description: 'Project directory path' },
+            symbolType: {
+                type: 'string',
+                enum: ['all', 'function', 'class', 'interface', 'variable', 'type'],
+                description: 'Type of symbol to search for'
+            }
+        },
+        required: ['symbolName', 'projectPath']
+    },
+    annotations: {
+        title: 'Find Symbol',
+        audience: ['user', 'assistant']
+    }
+};
+export async function findSymbol(args) {
+    const { symbolName, projectPath, symbolType = 'all' } = args;
+    try {
+        // Use cached project for performance
+        const projectCache = ProjectCache.getInstance();
+        const project = projectCache.getOrCreate(projectPath);
+        const symbols = [];
+        // Check for Python files
+        const glob = await import('glob');
+        const pythonFiles = glob.globSync(path.join(projectPath, '**/*.py'), {
+            ignore: ['**/node_modules/**', '**/.git/**', '**/venv/**', '**/__pycache__/**']
+        });
+        // Parse Python files
+        for (const pyFile of pythonFiles) {
+            try {
+                const content = await readFile(pyFile, 'utf-8');
+                const pythonSymbols = await PythonParser.findSymbols(content);
+                for (const pySymbol of pythonSymbols) {
+                    if (pySymbol.name.includes(symbolName) &&
+                        (symbolType === 'all' || symbolType === pySymbol.kind)) {
+                        symbols.push({
+                            name: pySymbol.name,
+                            kind: pySymbol.kind,
+                            filePath: pyFile,
+                            line: pySymbol.line,
+                            column: pySymbol.column,
+                            preview: pySymbol.docstring?.substring(0, 100) || `${pySymbol.kind} ${pySymbol.name}`
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                // Skip files that can't be parsed
+                console.error(`Error parsing Python file ${pyFile}:`, error);
+            }
+        }
+        // Search through all source files
+        for (const sourceFile of project.getSourceFiles()) {
+            const filePath = sourceFile.getFilePath();
+            // Skip node_modules and other irrelevant paths
+            if (filePath.includes('node_modules') || filePath.includes('.git')) {
+                continue;
+            }
+            // Find matching symbols based on type
+            sourceFile.forEachDescendant((node) => {
+                const nodeSymbol = extractSymbolInfo(node, symbolName, symbolType);
+                if (nodeSymbol) {
+                    const start = node.getStartLinePos();
+                    const pos = sourceFile.getLineAndColumnAtPos(start);
+                    symbols.push({
+                        name: nodeSymbol.name,
+                        kind: nodeSymbol.kind,
+                        filePath: filePath,
+                        line: pos.line,
+                        column: pos.column,
+                        preview: node.getText().substring(0, 100)
+                    });
+                }
+            });
+        }
+        // Sort by relevance (exact matches first)
+        symbols.sort((a, b) => {
+            const aExact = a.name === symbolName ? 0 : 1;
+            const bExact = b.name === symbolName ? 0 : 1;
+            return aExact - bExact;
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Found ${symbols.length} symbols:\n${symbols.slice(0, 20).map(s => `${s.name} (${s.kind}) - ${s.filePath}:${s.line}`).join('\n')}`
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Error finding symbol: ${error instanceof Error ? error.message : 'Unknown error'}`
+                }]
+        };
+    }
+}
+function extractSymbolInfo(node, symbolName, symbolType) {
+    const kind = node.getKind();
+    // Function declarations and expressions
+    if (symbolType === 'all' || symbolType === 'function') {
+        if (Node.isFunctionDeclaration(node) || Node.isMethodDeclaration(node)) {
+            const name = node.getName();
+            if (name && name.includes(symbolName)) {
+                return { name, kind: 'function' };
+            }
+        }
+        if (Node.isVariableDeclaration(node)) {
+            const name = node.getName();
+            const initializer = node.getInitializer();
+            if (name && name.includes(symbolName) &&
+                (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer))) {
+                return { name, kind: 'function' };
+            }
+        }
+    }
+    // Class declarations
+    if (symbolType === 'all' || symbolType === 'class') {
+        if (Node.isClassDeclaration(node)) {
+            const name = node.getName();
+            if (name && name.includes(symbolName)) {
+                return { name, kind: 'class' };
+            }
+        }
+    }
+    // Interface declarations
+    if (symbolType === 'all' || symbolType === 'interface') {
+        if (Node.isInterfaceDeclaration(node)) {
+            const name = node.getName();
+            if (name && name.includes(symbolName)) {
+                return { name, kind: 'interface' };
+            }
+        }
+    }
+    // Type aliases
+    if (symbolType === 'all' || symbolType === 'type') {
+        if (Node.isTypeAliasDeclaration(node)) {
+            const name = node.getName();
+            if (name && name.includes(symbolName)) {
+                return { name, kind: 'type' };
+            }
+        }
+    }
+    // Variables
+    if (symbolType === 'all' || symbolType === 'variable') {
+        if (Node.isVariableDeclaration(node)) {
+            const name = node.getName();
+            const initializer = node.getInitializer();
+            if (name && name.includes(symbolName) &&
+                !Node.isArrowFunction(initializer) && !Node.isFunctionExpression(initializer)) {
+                return { name, kind: 'variable' };
+            }
+        }
+    }
+    return null;
+}
+function generateSummary(symbols, query) {
+    if (symbols.length === 0) {
+        return `No symbols found matching "${query}"`;
+    }
+    const byKind = {};
+    symbols.forEach(s => {
+        byKind[s.kind] = (byKind[s.kind] || 0) + 1;
+    });
+    const summary = Object.entries(byKind)
+        .map(([kind, count]) => `${count} ${kind}${count > 1 ? 's' : ''}`)
+        .join(', ');
+    return `Found ${symbols.length} symbols: ${summary}`;
+}
+function formatSymbolResults(result) {
+    let output = `# Symbol Search Results\n\n`;
+    output += `**Query:** ${result.query}\n`;
+    output += `**Type:** ${result.type}\n`;
+    output += `**Results:** ${result.resultsCount} symbols found\n\n`;
+    if (result.symbols.length === 0) {
+        output += `No symbols found matching "${result.query}".\n`;
+        return output;
+    }
+    output += `## Found Symbols\n\n`;
+    result.symbols.forEach((symbol, index) => {
+        output += `### ${index + 1}. ${symbol.name} (${symbol.kind})\n`;
+        output += `**Location:** ${symbol.filePath}:${symbol.line}:${symbol.column}\n`;
+        output += `**Preview:**\n\`\`\`typescript\n${symbol.preview}\n\`\`\`\n\n`;
+    });
+    output += `\n## Summary\n${result.summary}`;
+    return output;
+}

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

@@ -0,0 +1,50 @@
+// Sequential thinking tool - completely independent
+export const analyzeProblemDefinition = {
+    name: 'analyze_problem',
+    description: '문제 분석|어떻게 접근|분석해줘|analyze this|how to approach|break this down - Break down complex problem into structured steps',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            problem: { type: 'string', description: 'Problem to analyze' },
+            domain: { type: 'string', description: 'Problem domain' }
+        },
+        required: ['problem']
+    },
+    annotations: {
+        title: 'Analyze Problem',
+        audience: ['user', 'assistant']
+    }
+};
+export async function analyzeProblem(args) {
+    const { problem, domain = 'general' } = args;
+    const problemAnalysis = {
+        action: 'analyze_problem',
+        problem,
+        domain,
+        analysis: {
+            breakdown: [
+                'Define the problem clearly',
+                'Identify key constraints and requirements',
+                'Break down into smaller sub-problems',
+                'Determine solution approach',
+                'Plan implementation steps'
+            ],
+            considerations: [
+                'What are the inputs and expected outputs?',
+                'Are there any edge cases to consider?',
+                'What are the performance requirements?',
+                'How will this integrate with existing systems?'
+            ],
+            nextSteps: [
+                'Research existing solutions',
+                'Create detailed implementation plan',
+                'Identify potential risks and mitigation strategies',
+                'Define success criteria'
+            ]
+        },
+        status: 'success'
+    };
+    return {
+        content: [{ type: 'text', text: `Problem: ${problem}\nDomain: ${domain}\n\nBreakdown:\n${problemAnalysis.analysis.breakdown.map((b, i) => `${i + 1}. ${b}`).join('\n')}\n\nConsiderations:\n${problemAnalysis.analysis.considerations.map(c => `- ${c}`).join('\n')}\n\nNext Steps:\n${problemAnalysis.analysis.nextSteps.map(n => `- ${n}`).join('\n')}` }]
+    };
+}

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

@@ -0,0 +1,140 @@
+// Sequential thinking tool - completely independent
+import { Project, ScriptKind } from "ts-morph";
+const AST_PROJECT = new Project({
+    useInMemoryFileSystem: true,
+    compilerOptions: { allowJs: true, skipLibCheck: true }
+});
+export const breakDownProblemDefinition = {
+    name: 'break_down_problem',
+    description: '나눠서|단계별로|세분화|break down|divide|split into parts - Break complex problems into sub-problems',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            problem: { type: 'string', description: 'Complex problem to break down' },
+            maxDepth: { type: 'number', description: 'Maximum breakdown depth' },
+            approach: { type: 'string', description: 'Breakdown approach', enum: ['sequential', 'hierarchical', 'dependency-based'] }
+        },
+        required: ['problem']
+    },
+    annotations: {
+        title: 'Break Down Problem',
+        audience: ['user', 'assistant']
+    }
+};
+export async function breakDownProblem(args) {
+    const { problem: breakdownProblem, maxDepth = 3, approach = 'hierarchical' } = args;
+    // 코드로 추정되는 입력이면 AST 기반 구조 분해 시도
+    let codeStructureSubProblems = null;
+    if (breakdownProblem.includes('function') || breakdownProblem.includes('class') || breakdownProblem.includes('=>')) {
+        try {
+            const sourceFile = AST_PROJECT.createSourceFile('temp.ts', breakdownProblem, {
+                overwrite: true,
+                scriptKind: ScriptKind.TS
+            });
+            const funcs = sourceFile.getFunctions();
+            const classes = sourceFile.getClasses();
+            const vars = sourceFile.getVariableDeclarations();
+            codeStructureSubProblems = [];
+            funcs.forEach((f, i) => {
+                codeStructureSubProblems.push({
+                    id: `codeFunc${i + 1}`,
+                    title: `함수 분석: ${f.getName() || '익명함수'}`,
+                    description: f.getText().slice(0, 100) + (f.getText().length > 100 ? '...' : ''),
+                    complexity: 'medium',
+                    priority: 'high',
+                    dependencies: []
+                });
+            });
+            classes.forEach((c, i) => {
+                codeStructureSubProblems.push({
+                    id: `codeClass${i + 1}`,
+                    title: `클래스 분석: ${c.getName() || '익명클래스'}`,
+                    description: c.getText().slice(0, 100) + (c.getText().length > 100 ? '...' : ''),
+                    complexity: 'high',
+                    priority: 'high',
+                    dependencies: []
+                });
+            });
+            vars.forEach((v, i) => {
+                codeStructureSubProblems.push({
+                    id: `codeVar${i + 1}`,
+                    title: `변수 분석: ${v.getName()}`,
+                    description: v.getText().slice(0, 100) + (v.getText().length > 100 ? '...' : ''),
+                    complexity: 'low',
+                    priority: 'medium',
+                    dependencies: []
+                });
+            });
+            if (codeStructureSubProblems.length === 0)
+                codeStructureSubProblems = null;
+        }
+        catch (e) {
+            codeStructureSubProblems = null;
+        }
+    }
+    const generateSubProblems = (parentProblem, depth, maxDepth) => {
+        if (depth >= maxDepth)
+            return null;
+        const subProblems = [
+            {
+                id: `${depth}.1`,
+                title: `Understanding ${parentProblem}`,
+                description: `Analyze and understand the core aspects of ${parentProblem}`,
+                complexity: 'low',
+                priority: 'high',
+                dependencies: []
+            },
+            {
+                id: `${depth}.2`,
+                title: `Planning solution for ${parentProblem}`,
+                description: `Create detailed plan to solve ${parentProblem}`,
+                complexity: 'medium',
+                priority: 'high',
+                dependencies: [`${depth}.1`]
+            },
+            {
+                id: `${depth}.3`,
+                title: `Implementing solution for ${parentProblem}`,
+                description: `Execute the planned solution for ${parentProblem}`,
+                complexity: 'high',
+                priority: 'medium',
+                dependencies: [`${depth}.2`]
+            }
+        ];
+        if (depth < maxDepth - 1) {
+            subProblems.forEach((subProblem) => {
+                subProblem.subProblems = generateSubProblems(subProblem.title, depth + 1, maxDepth);
+            });
+        }
+        return subProblems;
+    };
+    const problemBreakdown = {
+        action: 'break_down_problem',
+        problem: breakdownProblem,
+        approach,
+        maxDepth,
+        breakdown: {
+            rootProblem: {
+                id: '0',
+                title: breakdownProblem,
+                description: `Root problem: ${breakdownProblem}`,
+                complexity: 'high',
+                subProblems: codeStructureSubProblems || generateSubProblems(breakdownProblem, 1, maxDepth)
+            }
+        },
+        executionOrder: approach === 'dependency-based' ?
+            ['Understanding phase', 'Planning phase', 'Implementation phase'] :
+            approach === 'sequential' ?
+                ['Step 1', 'Step 2', 'Step 3', '...'] :
+                ['Top-level analysis', 'Mid-level breakdown', 'Detailed tasks'],
+        status: 'success'
+    };
+    const formatSubProblems = (subs, indent = 0) => {
+        if (!subs)
+            return '';
+        return subs.map(s => `${'  '.repeat(indent)}- ${s.title} (${s.complexity}, ${s.priority})${s.subProblems ? '\n' + formatSubProblems(s.subProblems, indent + 1) : ''}`).join('\n');
+    };
+    return {
+        content: [{ type: 'text', text: `Problem: ${breakdownProblem}\nApproach: ${approach}\nMax Depth: ${maxDepth}\n\nBreakdown:\n${formatSubProblems(problemBreakdown.breakdown.rootProblem.subProblems)}\n\nExecution: ${problemBreakdown.executionOrder.join(' → ')}` }]
+    };
+}

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

@@ -0,0 +1,39 @@
+// Sequential thinking tool - completely independent
+export const createThinkingChainDefinition = {
+    name: 'create_thinking_chain',
+    description: '생각 과정|사고 흐름|연쇄적으로|thinking process|chain of thought|reasoning chain - Create sequential thinking chain',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            topic: { type: 'string', description: 'Topic to think about' },
+            steps: { type: 'number', description: 'Number of thinking steps' }
+        },
+        required: ['topic']
+    },
+    annotations: {
+        title: 'Create Thinking Chain',
+        audience: ['user', 'assistant']
+    }
+};
+export async function createThinkingChain(args) {
+    const { topic, steps = 5 } = args;
+    const thinkingChain = {
+        action: 'create_thinking_chain',
+        topic,
+        steps,
+        chain: Array.from({ length: steps }, (_, i) => ({
+            step: i + 1,
+            title: `Step ${i + 1}: Analyze ${topic}`,
+            content: `Think about ${topic} from perspective ${i + 1}`,
+            questions: [
+                `What are the key aspects of ${topic}?`,
+                `How does this relate to the overall problem?`,
+                `What are the potential implications?`
+            ]
+        })),
+        status: 'success'
+    };
+    return {
+        content: [{ type: 'text', text: `Topic: ${topic}\nSteps: ${steps}\n\n${thinkingChain.chain.map(s => `${s.step}. ${s.title}\n   ${s.content}\n   Q: ${s.questions.join(', ')}`).join('\n\n')}` }]
+    };
+}