@nahisaho/musubix-core 1.0.0

package/dist/codegen/dependency-analyzer.js

@@ -0,0 +1,661 @@
+/**
+ * Dependency Analyzer
+ *
+ * Analyzes code dependencies and generates dependency graphs
+ *
+ * @packageDocumentation
+ * @module codegen/dependency-analyzer
+ *
+ * @see REQ-COD-004 - Dependency Analysis
+ * @see Article VI - Implementation Standards
+ */
+/**
+ * Default configuration
+ */
+export const DEFAULT_ANALYZER_CONFIG = {
+    includeDevDependencies: false,
+    includeTypeOnly: true,
+    maxDependenciesPerModule: 20,
+    maxCouplingFactor: 0.5,
+    detectCycles: true,
+    detectUnused: true,
+};
+/**
+ * Built-in Node.js modules
+ */
+const BUILTIN_MODULES = new Set([
+    'assert', 'buffer', 'child_process', 'cluster', 'console', 'constants',
+    'crypto', 'dgram', 'dns', 'domain', 'events', 'fs', 'http', 'https',
+    'module', 'net', 'os', 'path', 'perf_hooks', 'process', 'punycode',
+    'querystring', 'readline', 'repl', 'stream', 'string_decoder', 'sys',
+    'timers', 'tls', 'tty', 'url', 'util', 'v8', 'vm', 'wasi', 'worker_threads', 'zlib',
+    'node:assert', 'node:buffer', 'node:child_process', 'node:cluster',
+    'node:console', 'node:constants', 'node:crypto', 'node:dgram', 'node:dns',
+    'node:domain', 'node:events', 'node:fs', 'node:http', 'node:https',
+    'node:module', 'node:net', 'node:os', 'node:path', 'node:perf_hooks',
+    'node:process', 'node:punycode', 'node:querystring', 'node:readline',
+    'node:repl', 'node:stream', 'node:string_decoder', 'node:sys',
+    'node:timers', 'node:tls', 'node:tty', 'node:url', 'node:util', 'node:v8',
+    'node:vm', 'node:wasi', 'node:worker_threads', 'node:zlib',
+]);
+/**
+ * Dependency Analyzer
+ */
+export class DependencyAnalyzer {
+    config;
+    constructor(config) {
+        this.config = { ...DEFAULT_ANALYZER_CONFIG, ...config };
+    }
+    /**
+     * Analyze dependencies in code
+     */
+    analyze(code, filePath) {
+        const dependencies = [];
+        // Parse import statements
+        dependencies.push(...this.parseImports(code, filePath));
+        // Parse require statements
+        dependencies.push(...this.parseRequires(code, filePath));
+        // Parse class relationships
+        dependencies.push(...this.parseClassRelationships(code, filePath));
+        // Parse type references
+        if (this.config.includeTypeOnly) {
+            dependencies.push(...this.parseTypeReferences(code, filePath));
+        }
+        return dependencies;
+    }
+    /**
+     * Analyze multiple files and build graph
+     */
+    analyzeProject(files) {
+        const graph = this.buildGraph(files);
+        const metrics = this.calculateMetrics(graph);
+        const issues = this.detectIssues(graph, metrics);
+        const recommendations = this.generateRecommendations(graph, metrics, issues);
+        return {
+            graph,
+            metrics,
+            issues,
+            recommendations,
+        };
+    }
+    /**
+     * Parse ES6 import statements
+     */
+    parseImports(code, source) {
+        const dependencies = [];
+        // Standard imports: import { x } from 'module'
+        const importRegex = /import\s+(?:(type)\s+)?(?:(\*\s+as\s+\w+)|(\w+)(?:\s*,\s*\{([^}]*)\})?|\{([^}]*)\})\s+from\s+['"]([^'"]+)['"]/g;
+        let match;
+        while ((match = importRegex.exec(code)) !== null) {
+            const isTypeOnly = match[1] === 'type';
+            const isNamespace = !!match[2];
+            const defaultImport = match[3];
+            const namedWithDefault = match[4];
+            const namedImports = match[5];
+            const target = match[6];
+            const line = code.substring(0, match.index).split('\n').length;
+            const specifiers = [];
+            if (defaultImport)
+                specifiers.push(defaultImport);
+            if (namedWithDefault) {
+                specifiers.push(...namedWithDefault.split(',').map((s) => s.trim()));
+            }
+            if (namedImports) {
+                specifiers.push(...namedImports.split(',').map((s) => s.trim().split(' as ')[0]));
+            }
+            dependencies.push({
+                source,
+                target,
+                type: 'import',
+                strength: this.calculateStrength(target),
+                moduleType: this.getModuleType(target),
+                specifiers: specifiers.length > 0 ? specifiers : undefined,
+                isDefault: !!defaultImport,
+                isNamespace,
+                isTypeOnly,
+                location: { line, column: 0 },
+            });
+        }
+        // Side-effect imports: import 'module'
+        const sideEffectRegex = /import\s+['"]([^'"]+)['"]/g;
+        while ((match = sideEffectRegex.exec(code)) !== null) {
+            const target = match[1];
+            const line = code.substring(0, match.index).split('\n').length;
+            // Skip if already captured
+            if (dependencies.some((d) => d.target === target))
+                continue;
+            dependencies.push({
+                source,
+                target,
+                type: 'import',
+                strength: 'weak',
+                moduleType: this.getModuleType(target),
+                location: { line, column: 0 },
+            });
+        }
+        return dependencies;
+    }
+    /**
+     * Parse CommonJS require statements
+     */
+    parseRequires(code, source) {
+        const dependencies = [];
+        const requireRegex = /(?:const|let|var)\s+(?:(\w+)|{([^}]+)})\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+        let match;
+        while ((match = requireRegex.exec(code)) !== null) {
+            const defaultRequire = match[1];
+            const destructured = match[2];
+            const target = match[3];
+            const line = code.substring(0, match.index).split('\n').length;
+            const specifiers = [];
+            if (defaultRequire)
+                specifiers.push(defaultRequire);
+            if (destructured) {
+                specifiers.push(...destructured.split(',').map((s) => s.trim().split(':')[0]));
+            }
+            dependencies.push({
+                source,
+                target,
+                type: 'require',
+                strength: this.calculateStrength(target),
+                moduleType: this.getModuleType(target),
+                specifiers: specifiers.length > 0 ? specifiers : undefined,
+                isDefault: !!defaultRequire,
+                location: { line, column: 0 },
+            });
+        }
+        // Dynamic require
+        const dynamicRegex = /require\s*\(\s*(['"`])([^'"]+)\1\s*\)/g;
+        while ((match = dynamicRegex.exec(code)) !== null) {
+            const target = match[2];
+            if (dependencies.some((d) => d.target === target))
+                continue;
+            const line = code.substring(0, match.index).split('\n').length;
+            dependencies.push({
+                source,
+                target,
+                type: 'dynamic',
+                strength: 'weak',
+                moduleType: this.getModuleType(target),
+                location: { line, column: 0 },
+            });
+        }
+        return dependencies;
+    }
+    /**
+     * Parse class relationships (extends, implements)
+     */
+    parseClassRelationships(code, source) {
+        const dependencies = [];
+        const classRegex = /class\s+\w+(?:\s+extends\s+(\w+))?(?:\s+implements\s+([^{]+))?\s*\{/g;
+        let match;
+        while ((match = classRegex.exec(code)) !== null) {
+            const extendsClass = match[1];
+            const implementsList = match[2];
+            const line = code.substring(0, match.index).split('\n').length;
+            if (extendsClass) {
+                dependencies.push({
+                    source,
+                    target: extendsClass,
+                    type: 'extends',
+                    strength: 'strong',
+                    moduleType: 'internal',
+                    location: { line, column: 0 },
+                });
+            }
+            if (implementsList) {
+                for (const impl of implementsList.split(',')) {
+                    dependencies.push({
+                        source,
+                        target: impl.trim(),
+                        type: 'implements',
+                        strength: 'strong',
+                        moduleType: 'internal',
+                        location: { line, column: 0 },
+                    });
+                }
+            }
+        }
+        return dependencies;
+    }
+    /**
+     * Parse type references
+     */
+    parseTypeReferences(code, source) {
+        const dependencies = [];
+        // Type annotations: : TypeName
+        const typeRegex = /:\s*(\w+)(?:<[^>]+>)?(?:\[\])?/g;
+        let match;
+        const foundTypes = new Set();
+        while ((match = typeRegex.exec(code)) !== null) {
+            const typeName = match[1];
+            // Skip primitives and common types
+            if (this.isPrimitive(typeName))
+                continue;
+            if (foundTypes.has(typeName))
+                continue;
+            foundTypes.add(typeName);
+            const line = code.substring(0, match.index).split('\n').length;
+            dependencies.push({
+                source,
+                target: typeName,
+                type: 'type-reference',
+                strength: 'weak',
+                moduleType: 'internal',
+                isTypeOnly: true,
+                location: { line, column: 0 },
+            });
+        }
+        return dependencies;
+    }
+    /**
+     * Build dependency graph
+     */
+    buildGraph(files) {
+        const modules = new Map();
+        const allDependencies = [];
+        // First pass: analyze all files
+        for (const file of files) {
+            const deps = this.analyze(file.content, file.path);
+            const exports = this.parseExports(file.content);
+            modules.set(file.path, {
+                path: file.path,
+                name: this.getModuleName(file.path),
+                type: 'internal',
+                exports,
+                dependencies: deps,
+                dependents: [],
+            });
+            allDependencies.push(...deps);
+        }
+        // Second pass: build dependents
+        for (const [path, module] of modules) {
+            for (const dep of module.dependencies) {
+                const resolvedTarget = this.resolveModule(dep.target, path);
+                const targetModule = modules.get(resolvedTarget);
+                if (targetModule) {
+                    targetModule.dependents.push(path);
+                }
+            }
+        }
+        // Find roots and leaves
+        const roots = [...modules.entries()]
+            .filter(([_, m]) => m.dependents.length === 0)
+            .map(([p]) => p);
+        const leaves = [...modules.entries()]
+            .filter(([_, m]) => m.dependencies.filter((d) => d.moduleType === 'internal').length === 0)
+            .map(([p]) => p);
+        // Detect cycles
+        const cycles = this.config.detectCycles ? this.detectCycles(modules) : [];
+        return {
+            modules,
+            dependencies: allDependencies,
+            roots,
+            leaves,
+            cycles,
+        };
+    }
+    /**
+     * Parse exports
+     */
+    parseExports(code) {
+        const exports = [];
+        // Named exports
+        const namedExportRegex = /export\s+(?:(async\s+)?function|class|const|let|var|interface|type|enum)\s+(\w+)/g;
+        let match;
+        while ((match = namedExportRegex.exec(code)) !== null) {
+            const name = match[2];
+            const line = code.substring(0, match.index).split('\n').length;
+            const isFunction = match[0].includes('function');
+            const isClass = match[0].includes('class');
+            const isInterface = match[0].includes('interface');
+            const isType = match[0].includes('type');
+            const isEnum = match[0].includes('enum');
+            exports.push({
+                name,
+                isDefault: false,
+                type: isFunction ? 'function' :
+                    isClass ? 'class' :
+                        isInterface ? 'interface' :
+                            isType ? 'type' :
+                                isEnum ? 'enum' : 'variable',
+                line,
+            });
+        }
+        // Default export
+        const defaultExportRegex = /export\s+default\s+(?:(async\s+)?function|class)?\s*(\w+)?/g;
+        while ((match = defaultExportRegex.exec(code)) !== null) {
+            const name = match[2] || 'default';
+            const line = code.substring(0, match.index).split('\n').length;
+            exports.push({
+                name,
+                isDefault: true,
+                type: match[0].includes('class') ? 'class' :
+                    match[0].includes('function') ? 'function' : 'variable',
+                line,
+            });
+        }
+        return exports;
+    }
+    /**
+     * Calculate metrics
+     */
+    calculateMetrics(graph) {
+        const totalModules = graph.modules.size;
+        const internalDeps = graph.dependencies.filter((d) => d.moduleType === 'internal');
+        const externalDeps = graph.dependencies.filter((d) => d.moduleType === 'external');
+        let maxDeps = 0;
+        let maxDepsModule;
+        for (const [path, module] of graph.modules) {
+            const depCount = module.dependencies.length;
+            if (depCount > maxDeps) {
+                maxDeps = depCount;
+                maxDepsModule = path;
+            }
+        }
+        const avgDeps = totalModules > 0
+            ? graph.dependencies.length / totalModules
+            : 0;
+        // Coupling factor: actual dependencies / maximum possible dependencies
+        const maxPossibleDeps = totalModules * (totalModules - 1);
+        const couplingFactor = maxPossibleDeps > 0
+            ? internalDeps.length / maxPossibleDeps
+            : 0;
+        // Graph complexity: edges - nodes + 2 * connected components
+        const edges = internalDeps.length;
+        const nodes = totalModules;
+        const connectedComponents = this.countConnectedComponents(graph);
+        const graphComplexity = Math.max(0, edges - nodes + 2 * connectedComponents);
+        return {
+            totalModules,
+            totalDependencies: graph.dependencies.length,
+            internalDependencies: internalDeps.length,
+            externalDependencies: externalDeps.length,
+            avgDependenciesPerModule: Math.round(avgDeps * 100) / 100,
+            maxDependencies: maxDeps,
+            maxDependenciesModule: maxDepsModule,
+            couplingFactor: Math.round(couplingFactor * 1000) / 1000,
+            graphComplexity,
+            cycleCount: graph.cycles.length,
+        };
+    }
+    /**
+     * Count connected components
+     */
+    countConnectedComponents(graph) {
+        const visited = new Set();
+        let components = 0;
+        for (const path of graph.modules.keys()) {
+            if (!visited.has(path)) {
+                this.dfs(path, graph, visited);
+                components++;
+            }
+        }
+        return components;
+    }
+    /**
+     * DFS for connected components
+     */
+    dfs(start, graph, visited) {
+        const stack = [start];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            if (visited.has(current))
+                continue;
+            visited.add(current);
+            const module = graph.modules.get(current);
+            if (module) {
+                for (const dep of module.dependencies) {
+                    const resolved = this.resolveModule(dep.target, current);
+                    if (graph.modules.has(resolved) && !visited.has(resolved)) {
+                        stack.push(resolved);
+                    }
+                }
+                for (const dependent of module.dependents) {
+                    if (!visited.has(dependent)) {
+                        stack.push(dependent);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Detect cycles using DFS
+     */
+    detectCycles(modules) {
+        const cycles = [];
+        const visited = new Set();
+        const recursionStack = new Set();
+        const path = [];
+        const dfs = (node) => {
+            if (recursionStack.has(node)) {
+                // Found cycle
+                const cycleStart = path.indexOf(node);
+                const cycle = path.slice(cycleStart);
+                cycle.push(node);
+                cycles.push(cycle);
+                return;
+            }
+            if (visited.has(node))
+                return;
+            visited.add(node);
+            recursionStack.add(node);
+            path.push(node);
+            const module = modules.get(node);
+            if (module) {
+                for (const dep of module.dependencies) {
+                    if (dep.moduleType === 'internal') {
+                        const resolved = this.resolveModule(dep.target, node);
+                        if (modules.has(resolved)) {
+                            dfs(resolved);
+                        }
+                    }
+                }
+            }
+            path.pop();
+            recursionStack.delete(node);
+        };
+        for (const path of modules.keys()) {
+            visited.clear();
+            recursionStack.clear();
+            dfs(path);
+        }
+        return cycles;
+    }
+    /**
+     * Detect issues
+     */
+    detectIssues(graph, metrics) {
+        const issues = [];
+        // Circular dependencies
+        for (const cycle of graph.cycles) {
+            issues.push({
+                id: `cycle-${cycle.join('-')}`,
+                severity: 'error',
+                type: 'cycle',
+                message: `Circular dependency detected: ${cycle.join(' → ')}`,
+                modules: cycle,
+                suggestion: 'Consider extracting shared code into a separate module',
+            });
+        }
+        // High coupling modules
+        for (const [path, module] of graph.modules) {
+            if (module.dependencies.length > this.config.maxDependenciesPerModule) {
+                issues.push({
+                    id: `high-coupling-${path}`,
+                    severity: 'warning',
+                    type: 'coupling',
+                    message: `Module ${path} has too many dependencies (${module.dependencies.length} > ${this.config.maxDependenciesPerModule})`,
+                    modules: [path],
+                    suggestion: 'Consider splitting this module or using dependency injection',
+                });
+            }
+        }
+        // High overall coupling
+        if (metrics.couplingFactor > this.config.maxCouplingFactor) {
+            issues.push({
+                id: 'high-overall-coupling',
+                severity: 'warning',
+                type: 'coupling',
+                message: `Overall coupling factor is too high (${metrics.couplingFactor} > ${this.config.maxCouplingFactor})`,
+                modules: [],
+                suggestion: 'Consider refactoring to reduce inter-module dependencies',
+            });
+        }
+        // Unused exports (if detectUnused is enabled)
+        if (this.config.detectUnused) {
+            for (const [path, module] of graph.modules) {
+                for (const exp of module.exports) {
+                    const isUsed = [...graph.modules.values()].some((m) => m.dependencies.some((d) => d.specifiers?.includes(exp.name)));
+                    if (!isUsed && !exp.isDefault && module.dependents.length === 0) {
+                        issues.push({
+                            id: `unused-export-${path}-${exp.name}`,
+                            severity: 'info',
+                            type: 'unused',
+                            message: `Export '${exp.name}' in ${path} appears to be unused`,
+                            modules: [path],
+                        });
+                    }
+                }
+            }
+        }
+        return issues;
+    }
+    /**
+     * Generate recommendations
+     */
+    generateRecommendations(graph, metrics, issues) {
+        const recommendations = [];
+        // Based on issues
+        if (issues.some((i) => i.type === 'cycle')) {
+            recommendations.push('Break circular dependencies by extracting shared interfaces');
+        }
+        if (issues.some((i) => i.type === 'coupling')) {
+            recommendations.push('Use dependency injection to reduce coupling');
+            recommendations.push('Consider applying the SOLID principles');
+        }
+        // Based on metrics
+        if (metrics.avgDependenciesPerModule > 10) {
+            recommendations.push('Average dependencies per module is high - consider splitting modules');
+        }
+        if (graph.roots.length === 0 && graph.modules.size > 0) {
+            recommendations.push('No root modules found - all modules have dependents');
+        }
+        if (metrics.graphComplexity > metrics.totalModules) {
+            recommendations.push('Graph complexity is high - simplify module relationships');
+        }
+        return recommendations;
+    }
+    /**
+     * Get module type
+     */
+    getModuleType(target) {
+        if (BUILTIN_MODULES.has(target))
+            return 'builtin';
+        if (target.startsWith('.') || target.startsWith('/'))
+            return 'relative';
+        if (target.startsWith('@') || /^[a-z]/i.test(target))
+            return 'external';
+        return 'internal';
+    }
+    /**
+     * Calculate dependency strength
+     */
+    calculateStrength(target) {
+        const type = this.getModuleType(target);
+        if (type === 'external')
+            return 'strong';
+        if (type === 'relative')
+            return 'medium';
+        return 'weak';
+    }
+    /**
+     * Check if type is primitive
+     */
+    isPrimitive(type) {
+        return ['string', 'number', 'boolean', 'void', 'null', 'undefined',
+            'any', 'unknown', 'never', 'object', 'symbol', 'bigint',
+            'Array', 'Object', 'Function', 'Promise', 'Map', 'Set',
+            'Record', 'Partial', 'Required', 'Readonly', 'Pick', 'Omit'].includes(type);
+    }
+    /**
+     * Get module name from path
+     */
+    getModuleName(path) {
+        const parts = path.split('/');
+        const filename = parts[parts.length - 1];
+        return filename.replace(/\.(ts|js|tsx|jsx)$/, '');
+    }
+    /**
+     * Resolve module path
+     */
+    resolveModule(target, source) {
+        // Handle aliases
+        if (this.config.aliases) {
+            for (const [alias, path] of Object.entries(this.config.aliases)) {
+                if (target.startsWith(alias)) {
+                    return target.replace(alias, path);
+                }
+            }
+        }
+        // Handle relative paths
+        if (target.startsWith('.')) {
+            const sourceParts = source.split('/');
+            sourceParts.pop();
+            const targetParts = target.split('/');
+            for (const part of targetParts) {
+                if (part === '..') {
+                    sourceParts.pop();
+                }
+                else if (part !== '.') {
+                    sourceParts.push(part);
+                }
+            }
+            return sourceParts.join('/');
+        }
+        return target;
+    }
+    /**
+     * Generate dependency report
+     */
+    generateReport(result) {
+        const lines = [];
+        lines.push('# Dependency Analysis Report');
+        lines.push('');
+        lines.push('## Metrics');
+        lines.push(`- Total Modules: ${result.metrics.totalModules}`);
+        lines.push(`- Total Dependencies: ${result.metrics.totalDependencies}`);
+        lines.push(`- Internal Dependencies: ${result.metrics.internalDependencies}`);
+        lines.push(`- External Dependencies: ${result.metrics.externalDependencies}`);
+        lines.push(`- Avg Dependencies/Module: ${result.metrics.avgDependenciesPerModule}`);
+        lines.push(`- Coupling Factor: ${result.metrics.couplingFactor}`);
+        lines.push(`- Cycles: ${result.metrics.cycleCount}`);
+        lines.push('');
+        if (result.issues.length > 0) {
+            lines.push('## Issues');
+            for (const issue of result.issues) {
+                const icon = issue.severity === 'error' ? '❌' :
+                    issue.severity === 'warning' ? '⚠️' : 'ℹ️';
+                lines.push(`${icon} [${issue.type}] ${issue.message}`);
+                if (issue.suggestion) {
+                    lines.push(`   → ${issue.suggestion}`);
+                }
+            }
+            lines.push('');
+        }
+        if (result.recommendations.length > 0) {
+            lines.push('## Recommendations');
+            for (const rec of result.recommendations) {
+                lines.push(`- ${rec}`);
+            }
+        }
+        return lines.join('\n');
+    }
+}
+/**
+ * Create dependency analyzer instance
+ */
+export function createDependencyAnalyzer(config) {
+    return new DependencyAnalyzer(config);
+}
+//# sourceMappingURL=dependency-analyzer.js.map