@su-record/vibe 0.1.2 → 0.1.4

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

@@ -1,248 +0,0 @@
-// Convention management tool - completely independent
-import { Project, ScriptKind } from "ts-morph";
-import { PythonParser } from '../../lib/PythonParser.js';
-// Reusable in-memory project to avoid re-parsing standard lib every call
-const AST_PROJECT = new Project({
-    useInMemoryFileSystem: true,
-    compilerOptions: { allowJs: true, skipLibCheck: true }
-});
-// Enhanced Software Engineering Metrics
-const CODE_QUALITY_METRICS = {
-    COMPLEXITY: {
-        maxCyclomaticComplexity: 10,
-        maxCognitiveComplexity: 15,
-        maxFunctionLines: 20,
-        maxNestingDepth: 3,
-        maxParameters: 5
-    },
-    COUPLING: {
-        maxDependencies: 7,
-        maxFanOut: 5,
-        preventCircularDeps: true
-    },
-    COHESION: {
-        singleResponsibility: true,
-        relatedFunctionsOnly: true
-    },
-    MAINTAINABILITY: {
-        noMagicNumbers: true,
-        consistentNaming: true,
-        properErrorHandling: true,
-        typesSafety: true
-    },
-    PERFORMANCE: {
-        memoizeExpensiveCalc: true,
-        lazyLoading: true,
-        batchOperations: true
-    }
-};
-export const analyzeComplexityDefinition = {
-    name: 'analyze_complexity',
-    description: '복잡도|복잡한지|complexity|how complex|난이도 - Analyze code complexity',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            code: { type: 'string', description: 'Code to analyze' },
-            metrics: { type: 'string', description: 'Metrics to calculate', enum: ['cyclomatic', 'cognitive', 'halstead', 'all'] }
-        },
-        required: ['code']
-    },
-    annotations: {
-        title: 'Analyze Complexity',
-        audience: ['user', 'assistant']
-    }
-};
-/**
- * Calculate cognitive complexity (how hard code is to understand)
- */
-function calculateCognitiveComplexity(code) {
-    const CONTROL_STRUCTURES = ['if', 'for', 'while'];
-    let cognitiveScore = 0;
-    const lines = code.split('\n');
-    let nestingLevel = 0;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        // Increment for control structures
-        if (CONTROL_STRUCTURES.some(keyword => trimmed.includes(keyword))) {
-            cognitiveScore += 1 + nestingLevel;
-        }
-        // Increment for catch/switch
-        if (trimmed.includes('catch') || trimmed.includes('switch')) {
-            cognitiveScore += 1 + nestingLevel;
-        }
-        // Update nesting level
-        const openBraces = (line.match(/\{/g) || []).length;
-        const closeBraces = (line.match(/\}/g) || []).length;
-        nestingLevel = Math.max(0, nestingLevel + openBraces - closeBraces);
-    }
-    const threshold = CODE_QUALITY_METRICS.COMPLEXITY.maxCognitiveComplexity;
-    return {
-        value: cognitiveScore,
-        threshold,
-        status: cognitiveScore <= threshold ? 'pass' : 'fail',
-        description: 'How difficult the code is to understand'
-    };
-}
-/**
- * Calculate AST-based cyclomatic complexity
- */
-function calculateAstComplexity(code) {
-    const CONTROL_FLOW_NODES = [
-        'IfStatement', 'ForStatement', 'ForOfStatement', 'ForInStatement',
-        'WhileStatement', 'CaseClause', 'ConditionalExpression',
-        'DoStatement', 'CatchClause', 'BinaryExpression'
-    ];
-    let astCyclomatic = 1;
-    try {
-        const sourceFile = AST_PROJECT.createSourceFile('temp.ts', code, {
-            overwrite: true,
-            scriptKind: ScriptKind.TS
-        });
-        sourceFile.forEachDescendant((node) => {
-            if (CONTROL_FLOW_NODES.includes(node.getKindName())) {
-                astCyclomatic++;
-            }
-        });
-        const threshold = CODE_QUALITY_METRICS.COMPLEXITY.maxCyclomaticComplexity;
-        return {
-            value: astCyclomatic,
-            threshold,
-            status: astCyclomatic <= threshold ? 'pass' : 'fail',
-            description: 'AST 기반 분기/조건문 수를 통한 cyclomatic complexity'
-        };
-    }
-    catch (e) {
-        return {
-            value: null,
-            status: 'error',
-            description: 'AST 분석 실패: ' + (e instanceof Error ? e.message : String(e))
-        };
-    }
-}
-/**
- * Analyze Python code complexity
- */
-async function analyzePythonComplexity(code) {
-    try {
-        const pythonComplexity = await PythonParser.analyzeComplexity(code);
-        const totalComplexity = pythonComplexity.cyclomaticComplexity;
-        const issues = [];
-        const MAX_COMPLEXITY = 10;
-        if (totalComplexity > MAX_COMPLEXITY) {
-            issues.push('High complexity');
-        }
-        pythonComplexity.functions.forEach(f => {
-            if (f.complexity > MAX_COMPLEXITY) {
-                issues.push(`Function ${f.name}: complexity ${f.complexity}`);
-            }
-        });
-        const issuesText = issues.length ? `\nIssues: ${issues.join(', ')}` : '';
-        return {
-            content: [{
-                    type: 'text',
-                    text: `Python Complexity: ${totalComplexity}\nFunctions: ${pythonComplexity.functions.length}\nClasses: ${pythonComplexity.classes.length}${issuesText}`
-                }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: `Python analysis error: ${error instanceof Error ? error.message : 'Unknown error'}`
-                }]
-        };
-    }
-}
-export async function analyzeComplexity(args) {
-    const { code: complexityCode, metrics: complexityMetrics = 'all' } = args;
-    // Check if this is Python code
-    if (PythonParser.isPythonCode(complexityCode)) {
-        return analyzePythonComplexity(complexityCode);
-    }
-    const complexityAnalysis = {
-        action: 'analyze_complexity',
-        metrics: complexityMetrics,
-        results: {},
-        overallScore: 0,
-        issues: [],
-        recommendations: [],
-        status: 'pending'
-    };
-    // AST 기반 cyclomatic complexity 분석
-    complexityAnalysis.results.astCyclomaticComplexity = calculateAstComplexity(complexityCode);
-    if (complexityMetrics === 'cyclomatic' || complexityMetrics === 'all') {
-        const cyclomaticComplexityScore = (complexityCode.match(/\bif\b|\bfor\b|\bwhile\b|\bcase\b|\b&&\b|\b\|\|\b/g) || []).length + 1;
-        complexityAnalysis.results.cyclomaticComplexity = {
-            value: cyclomaticComplexityScore,
-            threshold: CODE_QUALITY_METRICS.COMPLEXITY.maxCyclomaticComplexity,
-            status: cyclomaticComplexityScore <= CODE_QUALITY_METRICS.COMPLEXITY.maxCyclomaticComplexity ? 'pass' : 'fail',
-            description: 'Number of linearly independent paths through the code'
-        };
-    }
-    if (complexityMetrics === 'cognitive' || complexityMetrics === 'all') {
-        complexityAnalysis.results.cognitiveComplexity = calculateCognitiveComplexity(complexityCode);
-    }
-    if (complexityMetrics === 'halstead' || complexityMetrics === 'all') {
-        // Halstead metrics calculation (simplified version)
-        const operators = (complexityCode.match(/[+\-*/=<>!&|%^~?:]/g) || []).length;
-        const operands = (complexityCode.match(/\b[a-zA-Z_]\w*\b/g) || []).length;
-        const uniqueOperators = new Set(complexityCode.match(/[+\-*/=<>!&|%^~?:]/g) || []).size;
-        const uniqueOperands = new Set(complexityCode.match(/\b[a-zA-Z_]\w*\b/g) || []).size;
-        const vocabulary = uniqueOperators + uniqueOperands;
-        const length = operators + operands;
-        const calculatedLength = vocabulary > 0 ? uniqueOperators * Math.log2(uniqueOperators) + uniqueOperands * Math.log2(uniqueOperands) : 0;
-        const volume = length * Math.log2(vocabulary);
-        const difficulty = vocabulary > 0 ? (uniqueOperators / 2) * (operands / uniqueOperands) : 0;
-        const effort = difficulty * volume;
-        complexityAnalysis.results.halsteadMetrics = {
-            vocabulary: vocabulary,
-            length: length,
-            calculatedLength: Math.round(calculatedLength),
-            volume: Math.round(volume),
-            difficulty: Math.round(difficulty * 100) / 100,
-            effort: Math.round(effort),
-            timeToProgram: Math.round(effort / 18), // Halstead's formula: effort / 18 seconds
-            bugsDelivered: Math.round(volume / 3000 * 100) / 100, // Halstead's formula: volume / 3000
-            description: 'Software science metrics measuring program complexity'
-        };
-    }
-    // Additional complexity metrics
-    if (complexityMetrics === 'all') {
-        const lines = complexityCode.split('\n');
-        const nonEmptyLines = lines.filter(line => line.trim().length > 0).length;
-        const comments = (complexityCode.match(/\/\*[\s\S]*?\*\/|\/\/.*$/gm) || []).length;
-        const functions = (complexityCode.match(/function\s+\w+|\w+\s*=\s*\(/g) || []).length;
-        const classes = (complexityCode.match(/class\s+\w+/g) || []).length;
-        complexityAnalysis.results.additionalMetrics = {
-            linesOfCode: nonEmptyLines,
-            comments: comments,
-            commentRatio: nonEmptyLines > 0 ? Math.round((comments / nonEmptyLines) * 100) / 100 : 0,
-            functions: functions,
-            classes: classes,
-            averageFunctionLength: functions > 0 ? Math.round(nonEmptyLines / functions) : 0
-        };
-    }
-    // Overall assessment
-    const issues = [];
-    let overallScore = 100;
-    if (complexityAnalysis.results.cyclomaticComplexity && complexityAnalysis.results.cyclomaticComplexity.status === 'fail') {
-        issues.push('High cyclomatic complexity detected');
-        overallScore -= 20;
-    }
-    if (complexityAnalysis.results.cognitiveComplexity && complexityAnalysis.results.cognitiveComplexity.status === 'fail') {
-        issues.push('High cognitive complexity detected');
-        overallScore -= 25;
-    }
-    if (complexityAnalysis.results.halsteadMetrics && complexityAnalysis.results.halsteadMetrics.difficulty > 10) {
-        issues.push('High Halstead difficulty detected');
-        overallScore -= 15;
-    }
-    complexityAnalysis.overallScore = Math.max(0, overallScore);
-    complexityAnalysis.issues = issues;
-    return {
-        content: [{
-                type: 'text',
-                text: `Complexity: ${complexityAnalysis.results.astCyclomaticComplexity?.value ?? 'N/A'}\nScore: ${complexityAnalysis.overallScore}${issues.length ? '\nIssues: ' + issues.join(', ') : ''}`
-            }]
-    };
-}

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

@@ -1,102 +0,0 @@
-// Convention management tool - completely independent
-// Code Quality Standards
-const QUALITY_RULES = {
-    NAMING: {
-        variables: 'nouns (userList, userData)',
-        functions: 'verb+noun (fetchData, updateUser)',
-        events: 'handle prefix (handleClick, handleSubmit)',
-        booleans: 'is/has/can prefix (isLoading, hasError, canEdit)',
-        constants: 'UPPER_SNAKE_CASE (MAX_RETRY_COUNT, API_TIMEOUT)',
-        components: 'PascalCase (UserProfile, HeaderSection)',
-        hooks: 'use prefix (useUserData, useAuth)'
-    },
-    STRUCTURE: {
-        componentOrder: ['State & Refs', 'Custom Hooks', 'Event Handlers', 'Effects', 'Early returns', 'Main return JSX'],
-        functionMaxLines: 20,
-        componentMaxLines: 50,
-        maxNestingDepth: 3
-    },
-    ANTIPATTERNS: {
-        typescript: ['any type usage', '@ts-ignore usage', 'as any casting'],
-        react: ['dangerouslySetInnerHTML', 'props drilling (3+ levels)'],
-        javascript: ['var usage', '== instead of ===', 'eval() usage'],
-        css: ['!important abuse', 'inline style abuse']
-    },
-    ASYNC_STATES: ['data', 'isLoading', 'error'],
-    STATE_MANAGEMENT: {
-        simple: 'useState',
-        complex: 'useReducer',
-        globalUI: 'Context API',
-        globalApp: 'Zustand',
-        server: 'TanStack Query'
-    }
-};
-export const applyQualityRulesDefinition = {
-    name: 'apply_quality_rules',
-    description: '규칙 적용|표준 적용|apply rules|apply standards|follow conventions|적용해 - Apply quality rules',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            scope: { type: 'string', description: 'Application scope', enum: ['naming', 'structure', 'typescript', 'react', 'accessibility', 'all'] },
-            language: { type: 'string', description: 'Programming language context', enum: ['javascript', 'typescript', 'react', 'vue', 'general'] }
-        },
-        required: ['scope']
-    },
-    annotations: {
-        title: 'Apply Quality Rules',
-        audience: ['user', 'assistant']
-    }
-};
-export async function applyQualityRules(args) {
-    const { scope, language: contextLanguage = 'general' } = args;
-    const applicableRules = [];
-    if (scope === 'naming' || scope === 'all') {
-        applicableRules.push({
-            category: 'Naming Conventions',
-            rules: QUALITY_RULES.NAMING
-        });
-    }
-    if (scope === 'structure' || scope === 'all') {
-        applicableRules.push({
-            category: 'Code Structure',
-            rules: QUALITY_RULES.STRUCTURE
-        });
-    }
-    if (scope === 'typescript' || scope === 'all') {
-        applicableRules.push({
-            category: 'TypeScript Guidelines',
-            rules: QUALITY_RULES.ANTIPATTERNS.typescript
-        });
-    }
-    if (scope === 'react' || scope === 'all') {
-        applicableRules.push({
-            category: 'React Guidelines',
-            rules: QUALITY_RULES.ANTIPATTERNS.react
-        });
-    }
-    if (scope === 'accessibility' || scope === 'all') {
-        applicableRules.push({
-            category: 'Accessibility Guidelines',
-            rules: [
-                'Use semantic HTML elements',
-                'Provide alt text for images',
-                'Ensure keyboard navigation',
-                'Maintain color contrast ratios',
-                'Use ARIA labels when needed'
-            ]
-        });
-    }
-    const qualityRulesResult = {
-        action: 'apply_quality_rules',
-        scope,
-        language: contextLanguage,
-        rules: applicableRules,
-        asyncStates: QUALITY_RULES.ASYNC_STATES,
-        stateManagement: QUALITY_RULES.STATE_MANAGEMENT,
-        status: 'success'
-    };
-    const rulesSummary = applicableRules.map(r => `${r.category}: ${Array.isArray(r.rules) ? r.rules.length + ' rules' : Object.keys(r.rules).length + ' items'}`).join(', ');
-    return {
-        content: [{ type: 'text', text: `Scope: ${scope}\nLanguage: ${contextLanguage}\nRules Applied: ${rulesSummary}\n\nAsync States: ${QUALITY_RULES.ASYNC_STATES.join(', ')}\n\nState Mgmt:\n${Object.entries(QUALITY_RULES.STATE_MANAGEMENT).map(([k, v]) => `- ${k}: ${v}`).join('\n')}` }]
-    };
-}

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

@@ -1,233 +0,0 @@
-// Convention management tool - completely independent
-// Enhanced Software Engineering Metrics
-const CODE_QUALITY_METRICS = {
-    COMPLEXITY: {
-        maxCyclomaticComplexity: 10,
-        maxCognitiveComplexity: 15,
-        maxFunctionLines: 20,
-        maxNestingDepth: 3,
-        maxParameters: 5
-    },
-    COUPLING: {
-        maxDependencies: 7,
-        maxFanOut: 5,
-        preventCircularDeps: true
-    },
-    COHESION: {
-        singleResponsibility: true,
-        relatedFunctionsOnly: true
-    },
-    MAINTAINABILITY: {
-        noMagicNumbers: true,
-        consistentNaming: true,
-        properErrorHandling: true,
-        typesSafety: true
-    },
-    PERFORMANCE: {
-        memoizeExpensiveCalc: true,
-        lazyLoading: true,
-        batchOperations: true
-    }
-};
-export const checkCouplingCohesionDefinition = {
-    name: 'check_coupling_cohesion',
-    description: '결합도|응집도|coupling|cohesion|dependencies check|module structure - Check coupling and cohesion',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            code: { type: 'string', description: 'Code to analyze' },
-            type: { type: 'string', description: 'Code type', enum: ['class', 'module', 'function', 'component'] },
-            checkDependencies: { type: 'boolean', description: 'Analyze dependencies' }
-        },
-        required: ['code']
-    },
-    annotations: {
-        title: 'Check Coupling & Cohesion',
-        audience: ['user', 'assistant']
-    }
-};
-import { Project, ScriptKind } from "ts-morph";
-import * as ts from "typescript";
-const AST_PROJECT = new Project({
-    useInMemoryFileSystem: true,
-    compilerOptions: { allowJs: true, skipLibCheck: true }
-});
-export async function checkCouplingCohesion(args) {
-    const { code: couplingCode, type: couplingType = 'function', checkDependencies = false } = args;
-    const couplingAnalysis = {
-        action: 'check_coupling_cohesion',
-        type: couplingType,
-        checkDependencies,
-        results: {},
-        overallScore: 0,
-        issues: [],
-        recommendations: [],
-        status: 'pending'
-    };
-    // AST 기반 의존성/구조 분석
-    try {
-        const sourceFile = AST_PROJECT.createSourceFile('temp.ts', couplingCode, {
-            overwrite: true,
-            scriptKind: ScriptKind.TS
-        });
-        // Import/Require 분석
-        const importDecls = sourceFile.getImportDeclarations();
-        const requireCalls = sourceFile.getDescendantsOfKind(ts.SyntaxKind.CallExpression).filter(call => call.getExpression().getText() === 'require');
-        // 클래스/함수/모듈 구조 분석
-        const classDecls = sourceFile.getClasses();
-        const funcDecls = sourceFile.getFunctions();
-        const exportDecls = sourceFile.getExportDeclarations();
-        couplingAnalysis.results.ast = {
-            importCount: importDecls.length,
-            requireCount: requireCalls.length,
-            classCount: classDecls.length,
-            functionCount: funcDecls.length,
-            exportCount: exportDecls.length,
-            importModules: importDecls.map(d => d.getModuleSpecifierValue()),
-            exportedNames: exportDecls.map(d => d.getNamedExports().map(e => e.getName()))
-        };
-    }
-    catch (e) {
-        couplingAnalysis.results.ast = {
-            error: 'AST 분석 실패: ' + (e instanceof Error ? e.message : String(e))
-        };
-    }
-    // Dependency analysis (Coupling)
-    const imports = (couplingCode.match(/import\s+.*?\s+from\s+['"](.*?)['"]/g) || []).length;
-    const requires = (couplingCode.match(/require\s*\(\s*['"](.*?)['"]\s*\)/g) || []).length;
-    const totalDependencies = imports + requires;
-    // External dependencies
-    const externalDeps = (couplingCode.match(/import\s+.*?\s+from\s+['"](?!\.)(.*?)['"]/g) || []).length;
-    const internalDeps = totalDependencies - externalDeps;
-    // Function calls (fan-out)
-    const functionCalls = (couplingCode.match(/\w+\s*\(/g) || []).length;
-    const uniqueFunctionCalls = new Set((couplingCode.match(/\w+\s*\(/g) || []).map(call => call.replace(/\s*\(/, ''))).size;
-    couplingAnalysis.results.coupling = {
-        totalDependencies: totalDependencies,
-        externalDependencies: externalDeps,
-        internalDependencies: internalDeps,
-        functionCalls: functionCalls,
-        uniqueFunctionCalls: uniqueFunctionCalls,
-        threshold: CODE_QUALITY_METRICS.COUPLING.maxDependencies,
-        status: totalDependencies <= CODE_QUALITY_METRICS.COUPLING.maxDependencies ? 'pass' : 'fail',
-        fanOut: uniqueFunctionCalls,
-        fanOutStatus: uniqueFunctionCalls <= CODE_QUALITY_METRICS.COUPLING.maxFanOut ? 'pass' : 'fail'
-    };
-    // Cohesion analysis
-    let cohesionScore = 0;
-    let cohesionLevel = 'low';
-    if (couplingType === 'class') {
-        // Class cohesion: methods using same data
-        const methods = (couplingCode.match(/\w+\s*\([^)]*\)\s*\{/g) || []).length;
-        const properties = (couplingCode.match(/this\.\w+/g) || []).length;
-        const uniqueProperties = new Set((couplingCode.match(/this\.(\w+)/g) || []).map(prop => prop.replace('this.', ''))).size;
-        // LCOM (Lack of Cohesion in Methods) - simplified calculation
-        const propertyUsage = methods > 0 ? uniqueProperties / methods : 0;
-        cohesionScore = propertyUsage;
-        couplingAnalysis.results.cohesion = {
-            type: 'class',
-            methods: methods,
-            properties: uniqueProperties,
-            propertyUsageRatio: Math.round(propertyUsage * 100) / 100,
-            score: cohesionScore,
-            level: cohesionScore > 0.7 ? 'high' : cohesionScore > 0.4 ? 'medium' : 'low',
-            status: cohesionScore > 0.4 ? 'pass' : 'fail'
-        };
-    }
-    else if (couplingType === 'module') {
-        // Module cohesion: related functions and exports
-        const functions = (couplingCode.match(/function\s+\w+|const\s+\w+\s*=\s*\(/g) || []).length;
-        const exports = (couplingCode.match(/export\s+/g) || []).length;
-        const variables = (couplingCode.match(/(?:const|let|var)\s+\w+/g) || []).length;
-        // Functional cohesion: ratio of related functions
-        const cohesionRatio = functions > 0 ? exports / functions : 0;
-        cohesionScore = cohesionRatio;
-        couplingAnalysis.results.cohesion = {
-            type: 'module',
-            functions: functions,
-            exports: exports,
-            variables: variables,
-            cohesionRatio: Math.round(cohesionRatio * 100) / 100,
-            score: cohesionScore,
-            level: cohesionScore > 0.6 ? 'high' : cohesionScore > 0.3 ? 'medium' : 'low',
-            status: cohesionScore > 0.3 ? 'pass' : 'fail'
-        };
-    }
-    else if (couplingType === 'function') {
-        // Function cohesion: single responsibility principle
-        const statements = (couplingCode.match(/;/g) || []).length;
-        const returns = (couplingCode.match(/\breturn\b/g) || []).length;
-        const variables = (couplingCode.match(/(?:const|let|var)\s+\w+/g) || []).length;
-        // Sequential cohesion: operations flow in sequence
-        const lines = couplingCode.split('\n').filter(line => line.trim().length > 0).length;
-        const complexityIndicators = (couplingCode.match(/\bif\b|\bfor\b|\bwhile\b|\bswitch\b/g) || []).length;
-        cohesionScore = lines > 0 ? 1 - (complexityIndicators / lines) : 0;
-        couplingAnalysis.results.cohesion = {
-            type: 'function',
-            statements: statements,
-            returns: returns,
-            variables: variables,
-            lines: lines,
-            complexityIndicators: complexityIndicators,
-            score: Math.round(cohesionScore * 100) / 100,
-            level: cohesionScore > 0.7 ? 'high' : cohesionScore > 0.4 ? 'medium' : 'low',
-            status: cohesionScore > 0.4 ? 'pass' : 'fail'
-        };
-    }
-    else if (couplingType === 'component') {
-        // React component cohesion: props and state usage
-        const props = (couplingCode.match(/props\.\w+/g) || []).length;
-        const state = (couplingCode.match(/useState|useReducer/g) || []).length;
-        const effects = (couplingCode.match(/useEffect/g) || []).length;
-        const hooks = (couplingCode.match(/use\w+/g) || []).length;
-        // Component cohesion: how well props, state, and effects are related
-        const totalElements = props + state + effects;
-        const cohesionRatio = totalElements > 0 ? hooks / totalElements : 0;
-        cohesionScore = Math.min(1, cohesionRatio);
-        couplingAnalysis.results.cohesion = {
-            type: 'component',
-            props: props,
-            state: state,
-            effects: effects,
-            hooks: hooks,
-            cohesionRatio: Math.round(cohesionRatio * 100) / 100,
-            score: Math.round(cohesionScore * 100) / 100,
-            level: cohesionScore > 0.6 ? 'high' : cohesionScore > 0.3 ? 'medium' : 'low',
-            status: cohesionScore > 0.3 ? 'pass' : 'fail'
-        };
-    }
-    // Overall assessment
-    const issues = [];
-    let overallScore = 100;
-    if (couplingAnalysis.results.coupling.status === 'fail') {
-        issues.push('High coupling detected - too many dependencies');
-        overallScore -= 30;
-    }
-    if (couplingAnalysis.results.coupling.fanOutStatus === 'fail') {
-        issues.push('High fan-out detected - too many function calls');
-        overallScore -= 20;
-    }
-    if (couplingAnalysis.results.cohesion.status === 'fail') {
-        issues.push('Low cohesion detected - poor single responsibility');
-        overallScore -= 25;
-    }
-    couplingAnalysis.overallScore = Math.max(0, overallScore);
-    couplingAnalysis.issues = issues;
-    couplingAnalysis.recommendations = [];
-    if (couplingAnalysis.results.coupling.status === 'fail') {
-        couplingAnalysis.recommendations.push('Reduce dependencies by using dependency injection');
-        couplingAnalysis.recommendations.push('Consider using interfaces to abstract dependencies');
-    }
-    if (couplingAnalysis.results.cohesion.status === 'fail') {
-        couplingAnalysis.recommendations.push('Ensure single responsibility principle');
-        couplingAnalysis.recommendations.push('Group related functionality together');
-        couplingAnalysis.recommendations.push('Extract unrelated code into separate modules');
-    }
-    if (couplingAnalysis.recommendations.length === 0) {
-        couplingAnalysis.recommendations.push('Coupling and cohesion are within acceptable ranges');
-    }
-    couplingAnalysis.status = 'success';
-    return {
-        content: [{ type: 'text', text: `Type: ${couplingType}\nScore: ${couplingAnalysis.overallScore}/100\n\nCoupling: ${couplingAnalysis.results.coupling.totalDependencies} deps (${couplingAnalysis.results.coupling.status}) | Fan-out: ${couplingAnalysis.results.coupling.fanOut} (${couplingAnalysis.results.coupling.fanOutStatus})\nCohesion: ${couplingAnalysis.results.cohesion.score} (${couplingAnalysis.results.cohesion.level}, ${couplingAnalysis.results.cohesion.status})\n\nIssues (${couplingAnalysis.issues.length}):\n${couplingAnalysis.issues.map(i => `- ${i}`).join('\n')}\n\nRecommendations:\n${couplingAnalysis.recommendations.map(r => `- ${r}`).join('\n')}` }]
-    };
-}