@su-record/vibe 0.1.2 → 0.1.4

package/mcp/dist/tools/convention/complexityMetrics.js

@@ -1,133 +0,0 @@
-// Complexity metrics calculation - extracted from analyzeComplexity
-import { Project, ScriptKind } from "ts-morph";
-const AST_PROJECT = new Project({
-    useInMemoryFileSystem: true,
-    compilerOptions: { allowJs: true, skipLibCheck: true }
-});
-const COMPLEXITY_NODES = new Set([
-    'IfStatement', 'ForStatement', 'ForOfStatement', 'ForInStatement',
-    'WhileStatement', 'CaseClause', 'ConditionalExpression',
-    'DoStatement', 'CatchClause', 'BinaryExpression'
-]);
-export const THRESHOLDS = {
-    maxCyclomatic: 10,
-    maxCognitive: 15,
-    maxHalsteadDifficulty: 10
-};
-/**
- * Calculate AST-based cyclomatic complexity
- */
-export function calculateASTCyclomatic(code) {
-    try {
-        const sourceFile = AST_PROJECT.createSourceFile('temp.ts', code, {
-            overwrite: true,
-            scriptKind: ScriptKind.TS
-        });
-        let complexity = 1;
-        sourceFile.forEachDescendant((node) => {
-            if (COMPLEXITY_NODES.has(node.getKindName())) {
-                complexity++;
-            }
-        });
-        return {
-            value: complexity,
-            threshold: THRESHOLDS.maxCyclomatic,
-            status: complexity <= THRESHOLDS.maxCyclomatic ? 'pass' : 'fail',
-            description: 'AST-based branch/decision point count'
-        };
-    }
-    catch (error) {
-        return {
-            value: 0,
-            status: 'error',
-            description: `AST analysis failed: ${error instanceof Error ? error.message : String(error)}`
-        };
-    }
-}
-/**
- * Calculate regex-based cyclomatic complexity (fallback)
- */
-export function calculateRegexCyclomatic(code) {
-    const patterns = /\bif\b|\bfor\b|\bwhile\b|\bcase\b|\b&&\b|\b\|\|\b/g;
-    const matches = code.match(patterns) || [];
-    const complexity = matches.length + 1;
-    return {
-        value: complexity,
-        threshold: THRESHOLDS.maxCyclomatic,
-        status: complexity <= THRESHOLDS.maxCyclomatic ? 'pass' : 'fail',
-        description: 'Number of linearly independent paths'
-    };
-}
-/**
- * Calculate cognitive complexity with nesting awareness
- */
-export function calculateCognitiveComplexity(code) {
-    const lines = code.split('\n');
-    let complexity = 0;
-    let nestingLevel = 0;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        // Control structures add complexity based on nesting
-        if (/(if|for|while|catch|switch)\s*\(/.test(trimmed)) {
-            complexity += 1 + nestingLevel;
-        }
-        // Track nesting level
-        const openBraces = (line.match(/\{/g) || []).length;
-        const closeBraces = (line.match(/\}/g) || []).length;
-        nestingLevel = Math.max(0, nestingLevel + openBraces - closeBraces);
-    }
-    return {
-        value: complexity,
-        threshold: THRESHOLDS.maxCognitive,
-        status: complexity <= THRESHOLDS.maxCognitive ? 'pass' : 'fail',
-        description: 'Difficulty to understand the code'
-    };
-}
-/**
- * Calculate Halstead complexity metrics
- */
-export function calculateHalsteadMetrics(code) {
-    const operators = code.match(/[+\-*/=<>!&|%^~?:]/g) || [];
-    const operands = code.match(/\b[a-zA-Z_]\w*\b/g) || [];
-    const uniqueOperators = new Set(operators).size;
-    const uniqueOperands = new Set(operands).size;
-    const vocabulary = uniqueOperators + uniqueOperands;
-    const length = operators.length + operands.length;
-    const calculatedLength = vocabulary > 0
-        ? uniqueOperators * Math.log2(uniqueOperators || 1) + uniqueOperands * Math.log2(uniqueOperands || 1)
-        : 0;
-    const volume = length * Math.log2(vocabulary || 1);
-    const difficulty = vocabulary > 0
-        ? (uniqueOperators / 2) * (operands.length / (uniqueOperands || 1))
-        : 0;
-    const effort = difficulty * volume;
-    return {
-        vocabulary,
-        length,
-        calculatedLength: Math.round(calculatedLength),
-        volume: Math.round(volume),
-        difficulty: Math.round(difficulty * 100) / 100,
-        effort: Math.round(effort),
-        timeToProgram: Math.round(effort / 18),
-        bugsDelivered: Math.round(volume / 3000 * 100) / 100,
-        description: 'Software science metrics measuring program complexity'
-    };
-}
-/**
- * Calculate additional code metrics
- */
-export function calculateAdditionalMetrics(code) {
-    const lines = code.split('\n');
-    const nonEmptyLines = lines.filter(line => line.trim().length > 0).length;
-    const comments = (code.match(/\/\*[\s\S]*?\*\/|\/\/.*$/gm) || []).length;
-    const functions = (code.match(/function\s+\w+|\w+\s*=\s*\(/g) || []).length;
-    const classes = (code.match(/class\s+\w+/g) || []).length;
-    return {
-        linesOfCode: nonEmptyLines,
-        comments,
-        commentRatio: nonEmptyLines > 0 ? Math.round((comments / nonEmptyLines) * 100) / 100 : 0,
-        functions,
-        classes,
-        averageFunctionLength: functions > 0 ? Math.round(nonEmptyLines / functions) : 0
-    };
-}

package/mcp/dist/tools/convention/dartComplexity.js

@@ -1,117 +0,0 @@
-/**
- * Dart/Flutter-specific complexity analysis
- */
-import { THRESHOLDS } from './complexityMetrics.js';
-/**
- * Calculate cyclomatic complexity for Dart code
- */
-export function calculateDartComplexity(code) {
-    // Dart control flow keywords
-    const patterns = [
-        /\bif\b/g, // if statements
-        /\belse\s+if\b/g, // else if
-        /\bfor\b/g, // for loops
-        /\bwhile\b/g, // while loops
-        /\bdo\b/g, // do-while
-        /\bswitch\b/g, // switch statements
-        /\bcase\b/g, // case clauses
-        /\btry\b/g, // try blocks
-        /\bcatch\b/g, // catch blocks
-        /&&/g, // logical and
-        /\|\|/g, // logical or
-        /\?\?/g // null-coalescing
-    ];
-    let complexity = 1; // Base complexity
-    for (const pattern of patterns) {
-        const matches = code.match(pattern);
-        if (matches) {
-            complexity += matches.length;
-        }
-    }
-    return {
-        value: complexity,
-        threshold: THRESHOLDS.maxCyclomatic,
-        status: complexity <= THRESHOLDS.maxCyclomatic ? 'pass' : 'fail',
-        description: 'Dart cyclomatic complexity (control flow branches)'
-    };
-}
-/**
- * Calculate cognitive complexity for Dart
- */
-export function calculateDartCognitiveComplexity(code) {
-    let complexity = 0;
-    // Nested control structures
-    let nestingLevel = 0;
-    const lines = code.split('\n');
-    for (const line of lines) {
-        const trimmed = line.trim();
-        // Track nesting level
-        const openBraces = (line.match(/{/g) || []).length;
-        const closeBraces = (line.match(/}/g) || []).length;
-        // Control flow keywords
-        if (/\b(if|else|for|while|switch|try|catch)\b/.test(trimmed)) {
-            complexity += 1 + nestingLevel;
-        }
-        // Ternary operators
-        const ternaryCount = (trimmed.match(/\?.*:/g) || []).length;
-        complexity += ternaryCount;
-        // Null-aware operators (Flutter specific)
-        const nullAwareCount = (trimmed.match(/\?\?|!\.|\/\?/g) || []).length;
-        complexity += nullAwareCount * 0.5; // Half weight
-        // Update nesting
-        nestingLevel += openBraces - closeBraces;
-        if (nestingLevel < 0)
-            nestingLevel = 0;
-    }
-    return {
-        value: Math.round(complexity),
-        threshold: THRESHOLDS.maxCognitive,
-        status: complexity <= THRESHOLDS.maxCognitive ? 'pass' : 'fail',
-        description: 'Dart cognitive complexity (mental load to understand)'
-    };
-}
-/**
- * Analyze Flutter/Dart code quality
- */
-export function analyzeDartQuality(code) {
-    const issues = [];
-    const recommendations = [];
-    // Flutter-specific anti-patterns
-    if (/setState\(\(\)\s*{\s*[\s\S]*?}\s*\)/.test(code)) {
-        const setStateCount = (code.match(/setState/g) || []).length;
-        if (setStateCount > 5) {
-            issues.push('Too many setState calls - consider state management solution');
-            recommendations.push('Use Provider, Riverpod, or Bloc for complex state');
-        }
-    }
-    // Deep widget nesting
-    const widgetNesting = (code.match(/child:\s*\w+\(/g) || []).length;
-    if (widgetNesting > 5) {
-        issues.push('Deep widget nesting detected');
-        recommendations.push('Extract nested widgets into separate methods or classes');
-    }
-    // Missing const constructors
-    const widgetConstructors = (code.match(/\w+\(/g) || []).length;
-    const constConstructors = (code.match(/const\s+\w+\(/g) || []).length;
-    if (widgetConstructors > 10 && constConstructors < widgetConstructors * 0.3) {
-        issues.push('Many widgets without const constructors');
-        recommendations.push('Use const constructors for immutable widgets to improve performance');
-    }
-    // Missing key in lists
-    if (/ListView\.builder|GridView\.builder/.test(code) && !/key:/.test(code)) {
-        issues.push('ListView/GridView without keys');
-        recommendations.push('Add keys to list items for better performance');
-    }
-    // Missing null safety
-    if (!/\w+\?|\w+!/.test(code) && code.includes('null')) {
-        issues.push('Possible null safety issues');
-        recommendations.push('Enable null safety and use ? and ! operators appropriately');
-    }
-    // Large build methods
-    const buildMethodMatch = code.match(/Widget build\(BuildContext context\)\s*{([\s\S]*?)^  }/m);
-    if (buildMethodMatch && buildMethodMatch[1].split('\n').length > 50) {
-        issues.push('Build method is too large (> 50 lines)');
-        recommendations.push('Extract widgets into separate methods or classes');
-    }
-    return { issues, recommendations };
-}

package/mcp/dist/tools/convention/getCodingGuide.js

@@ -1,64 +0,0 @@
-// Convention management tool - completely independent
-import { promises as fs } from 'fs';
-import path from 'path';
-const GUIDES_DIR = path.join(process.cwd(), 'guides');
-const GUIDES_FILE = path.join(GUIDES_DIR, 'coding_guides.json');
-async function ensureGuidesDir() {
-    try {
-        await fs.access(GUIDES_DIR);
-    }
-    catch {
-        await fs.mkdir(GUIDES_DIR, { recursive: true });
-    }
-}
-async function loadGuides() {
-    try {
-        await ensureGuidesDir();
-        const data = await fs.readFile(GUIDES_FILE, 'utf-8');
-        return JSON.parse(data);
-    }
-    catch {
-        return [];
-    }
-}
-async function findGuide(name) {
-    const guides = await loadGuides();
-    return guides.find(g => g.name === name);
-}
-export const getCodingGuideDefinition = {
-    name: 'get_coding_guide',
-    description: '가이드|규칙|컨벤션|guide|rules|convention|standards|best practices - Get coding guide',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            name: { type: 'string', description: 'Guide name to retrieve' },
-            category: { type: 'string', description: 'Guide category' }
-        },
-        required: ['name']
-    },
-    annotations: {
-        title: 'Get Coding Guide',
-        audience: ['user', 'assistant']
-    }
-};
-export async function getCodingGuide(args) {
-    const { name: guideName, category: guideCategory } = args;
-    try {
-        const guide = await findGuide(guideName);
-        if (guide) {
-            return {
-                content: [{ type: 'text', text: `Guide: ${guide.name}\nCategory: ${guide.category}\n\n${guide.content}\n\nTags: ${guide.tags.join(', ')} | Updated: ${guide.lastUpdated}` }]
-            };
-        }
-        else {
-            return {
-                content: [{ type: 'text', text: `Guide not found: "${guideName}". Use list_coding_guides to see available guides.` }]
-            };
-        }
-    }
-    catch (error) {
-        return {
-            content: [{ type: 'text', text: `Error retrieving guide: ${error instanceof Error ? error.message : 'Unknown error'}` }]
-        };
-    }
-}

package/mcp/dist/tools/convention/languageDetector.js

@@ -1,50 +0,0 @@
-/**
- * Language detection utility for code quality tools
- * Supports TypeScript, JavaScript, Python, and Dart/Flutter
- */
-export function detectLanguage(code) {
-    // Dart/Flutter indicators (check first - most specific)
-    if (/\bWidget\b/.test(code) ||
-        /\bStatelessWidget\b/.test(code) ||
-        /\bStatefulWidget\b/.test(code) ||
-        /\bBuildContext\b/.test(code) ||
-        /Widget build\(/.test(code) ||
-        /extends\s+(StatelessWidget|StatefulWidget|State)/.test(code) ||
-        (/@override/i.test(code) && /Widget|BuildContext/.test(code))) {
-        return 'dart';
-    }
-    // Python indicators
-    if (/^(def|async def)\s/m.test(code) ||
-        /^from\s+\w+\s+import/.test(code) ||
-        /^\s+def\s/m.test(code) || // Indented function definitions
-        /\belif\b/.test(code) ||
-        /\b__init__\b/.test(code) ||
-        /\bprint\(/m.test(code) ||
-        (/:\s*$/m.test(code) && !/;/.test(code)) // Python colon without semicolon
-    ) {
-        return 'python';
-    }
-    // TypeScript indicators
-    if (/:\s*(string|number|boolean|any|void|unknown|never)\b/.test(code) ||
-        /interface\s+\w+/.test(code) ||
-        /type\s+\w+\s*=/.test(code) ||
-        /<[A-Z]\w*>/.test(code) // generics with capital letters
-    ) {
-        return 'typescript';
-    }
-    // JavaScript (default if none match)
-    if (/\b(const|let|var|function|class|async|await|import|export)\b/.test(code)) {
-        return 'javascript';
-    }
-    return 'unknown';
-}
-export function getLanguageName(lang) {
-    const names = {
-        typescript: 'TypeScript',
-        javascript: 'JavaScript',
-        python: 'Python',
-        dart: 'Dart/Flutter',
-        unknown: 'Unknown'
-    };
-    return names[lang];
-}

package/mcp/dist/tools/convention/pythonComplexity.js

@@ -1,109 +0,0 @@
-/**
- * Python-specific complexity analysis
- */
-import { THRESHOLDS } from './complexityMetrics.js';
-/**
- * Calculate cyclomatic complexity for Python code
- */
-export function calculatePythonComplexity(code) {
-    // Python control flow keywords
-    const patterns = [
-        /\bif\b/g, // if statements
-        /\belif\b/g, // elif statements
-        /\bfor\b/g, // for loops
-        /\bwhile\b/g, // while loops
-        /\btry\b/g, // try blocks
-        /\bexcept\b/g, // except blocks
-        /\band\b/g, // logical and
-        /\bor\b/g, // logical or
-        /\bwith\b/g, // with statements
-        /\blambda\b/g // lambda expressions
-    ];
-    let complexity = 1; // Base complexity
-    for (const pattern of patterns) {
-        const matches = code.match(pattern);
-        if (matches) {
-            complexity += matches.length;
-        }
-    }
-    return {
-        value: complexity,
-        threshold: THRESHOLDS.maxCyclomatic,
-        status: complexity <= THRESHOLDS.maxCyclomatic ? 'pass' : 'fail',
-        description: 'Python cyclomatic complexity (control flow branches)'
-    };
-}
-/**
- * Calculate cognitive complexity for Python
- */
-export function calculatePythonCognitiveComplexity(code) {
-    let complexity = 0;
-    let nestingLevel = 0;
-    const lines = code.split('\n');
-    for (const line of lines) {
-        const trimmed = line.trim();
-        // Detect indentation level (Python uses indentation for nesting)
-        const indent = line.match(/^(\s*)/)?.[1].length || 0;
-        const currentNesting = Math.floor(indent / 4); // Assuming 4-space indents
-        // Control flow that increases cognitive load
-        if (/\b(if|elif|for|while|try|except|with)\b/.test(trimmed)) {
-            complexity += 1 + currentNesting;
-        }
-        // Logical operators increase complexity
-        const logicalOps = trimmed.match(/\b(and|or)\b/g);
-        if (logicalOps) {
-            complexity += logicalOps.length;
-        }
-        // List comprehensions add cognitive load
-        if (/\[.*for.*in.*\]/.test(trimmed)) {
-            complexity += 1;
-        }
-        // Nested functions
-        if (/^\s+def\s+/.test(line)) {
-            complexity += currentNesting;
-        }
-    }
-    return {
-        value: complexity,
-        threshold: THRESHOLDS.maxCognitive,
-        status: complexity <= THRESHOLDS.maxCognitive ? 'pass' : 'fail',
-        description: 'Python cognitive complexity (mental load to understand)'
-    };
-}
-/**
- * Analyze Python code quality
- */
-export function analyzePythonQuality(code) {
-    const issues = [];
-    const recommendations = [];
-    // Check for common Python anti-patterns
-    if (code.includes('eval(') || code.includes('exec(')) {
-        issues.push('Use of eval() or exec() detected - security risk');
-        recommendations.push('Avoid eval() and exec(), use safer alternatives');
-    }
-    if (/except:\s*$/.test(code)) {
-        issues.push('Bare except clause detected');
-        recommendations.push('Specify exception types: except ValueError:');
-    }
-    if (/import \*/.test(code)) {
-        issues.push('Wildcard import detected');
-        recommendations.push('Import specific names instead of using wildcard');
-    }
-    // Check for long functions
-    const functionMatches = code.match(/def\s+\w+\([^)]*\):/g) || [];
-    if (functionMatches.length > 0) {
-        const avgFunctionLength = code.split('\n').length / functionMatches.length;
-        if (avgFunctionLength > 50) {
-            issues.push('Functions are too long (avg > 50 lines)');
-            recommendations.push('Break down large functions into smaller ones');
-        }
-    }
-    // Check for PEP 8 violations (basic)
-    const lines = code.split('\n');
-    const longLines = lines.filter(line => line.length > 79);
-    if (longLines.length > lines.length * 0.2) {
-        issues.push('Many lines exceed 79 characters (PEP 8)');
-        recommendations.push('Keep lines under 79 characters for better readability');
-    }
-    return { issues, recommendations };
-}