@su-record/vibe 0.1.0

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

@@ -0,0 +1,233 @@
+// 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')}` }]
+    };
+}

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

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

@@ -0,0 +1,117 @@
+/**
+ * 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

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

@@ -0,0 +1,50 @@
+/**
+ * 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];
+}