@nahisaho/musubix-core 1.0.0

package/dist/codegen/quality-metrics.d.ts

@@ -0,0 +1,235 @@
+/**
+ * Quality Metrics Calculator
+ *
+ * Calculates code quality metrics
+ *
+ * @packageDocumentation
+ * @module codegen/quality-metrics
+ *
+ * @see REQ-QUA-001 - Quality Metrics
+ * @see Article VI - Quality Standards
+ */
+/**
+ * Quality metric type
+ */
+export type MetricType = 'loc' | 'sloc' | 'comments' | 'blank' | 'complexity' | 'maintainability' | 'duplication' | 'coupling' | 'cohesion' | 'test-coverage';
+/**
+ * Metric value
+ */
+export interface MetricValue {
+    /** Metric type */
+    type: MetricType;
+    /** Numeric value */
+    value: number;
+    /** Unit */
+    unit?: string;
+    /** Thresholds */
+    thresholds?: MetricThresholds;
+    /** Status */
+    status: 'good' | 'warning' | 'critical';
+}
+/**
+ * Metric thresholds
+ */
+export interface MetricThresholds {
+    /** Good threshold */
+    good: number;
+    /** Warning threshold */
+    warning: number;
+    /** Critical threshold */
+    critical: number;
+}
+/**
+ * File metrics
+ */
+export interface FileMetrics {
+    /** File path */
+    file: string;
+    /** Language */
+    language: string;
+    /** Metrics */
+    metrics: MetricValue[];
+    /** Functions/methods */
+    functions: FunctionMetrics[];
+    /** Classes */
+    classes: ClassMetrics[];
+}
+/**
+ * Function metrics
+ */
+export interface FunctionMetrics {
+    /** Function name */
+    name: string;
+    /** Line number */
+    line: number;
+    /** Lines of code */
+    loc: number;
+    /** Cyclomatic complexity */
+    complexity: number;
+    /** Parameters count */
+    parameters: number;
+    /** Nesting depth */
+    nestingDepth: number;
+    /** Cognitive complexity */
+    cognitiveComplexity: number;
+}
+/**
+ * Class metrics
+ */
+export interface ClassMetrics {
+    /** Class name */
+    name: string;
+    /** Line number */
+    line: number;
+    /** Methods count */
+    methodCount: number;
+    /** Properties count */
+    propertyCount: number;
+    /** Lines of code */
+    loc: number;
+    /** Weighted methods per class */
+    wmc: number;
+    /** Lack of cohesion */
+    lcom: number;
+    /** Depth of inheritance */
+    dit: number;
+    /** Number of children */
+    noc: number;
+    /** Coupling between objects */
+    cbo: number;
+}
+/**
+ * Project metrics summary
+ */
+export interface ProjectMetrics {
+    /** Total files */
+    totalFiles: number;
+    /** Total lines */
+    totalLines: number;
+    /** Average complexity */
+    averageComplexity: number;
+    /** Average maintainability */
+    averageMaintainability: number;
+    /** Duplication percentage */
+    duplicationPercentage: number;
+    /** Overall quality score */
+    qualityScore: number;
+    /** File metrics */
+    files: FileMetrics[];
+    /** Trends */
+    trends?: MetricTrends;
+}
+/**
+ * Metric trends
+ */
+export interface MetricTrends {
+    /** Period */
+    period: string;
+    /** Changes */
+    changes: Array<{
+        metric: MetricType;
+        previous: number;
+        current: number;
+        change: number;
+        direction: 'improved' | 'degraded' | 'stable';
+    }>;
+}
+/**
+ * Quality metrics calculator configuration
+ */
+export interface QualityMetricsConfig {
+    /** Include test files */
+    includeTests: boolean;
+    /** Calculate duplication */
+    calculateDuplication: boolean;
+    /** Duplication threshold (min lines) */
+    duplicationThreshold: number;
+    /** Complexity thresholds */
+    complexityThresholds: MetricThresholds;
+    /** Maintainability thresholds */
+    maintainabilityThresholds: MetricThresholds;
+}
+/**
+ * Default configuration
+ */
+export declare const DEFAULT_METRICS_CONFIG: QualityMetricsConfig;
+/**
+ * Quality Metrics Calculator
+ */
+export declare class QualityMetricsCalculator {
+    private config;
+    constructor(config?: Partial<QualityMetricsConfig>);
+    /**
+     * Calculate metrics for code
+     */
+    calculate(code: string, file: string, language?: string): FileMetrics;
+    /**
+     * Calculate metrics for multiple files
+     */
+    calculateProject(files: Array<{
+        path: string;
+        content: string;
+        language?: string;
+    }>): ProjectMetrics;
+    /**
+     * Count source lines (non-blank, non-comment)
+     */
+    private countSourceLines;
+    /**
+     * Count comment lines
+     */
+    private countCommentLines;
+    /**
+     * Count blank lines
+     */
+    private countBlankLines;
+    /**
+     * Calculate cyclomatic complexity
+     */
+    private calculateCyclomaticComplexity;
+    /**
+     * Calculate Halstead volume
+     */
+    private calculateHalsteadVolume;
+    /**
+     * Calculate maintainability index
+     */
+    private calculateMaintainabilityIndex;
+    /**
+     * Calculate code duplication percentage
+     */
+    private calculateDuplication;
+    /**
+     * Extract function metrics
+     */
+    private extractFunctionMetrics;
+    /**
+     * Count function parameters
+     */
+    private countParameters;
+    /**
+     * Calculate nesting depth
+     */
+    private calculateNestingDepth;
+    /**
+     * Calculate cognitive complexity
+     */
+    private calculateCognitiveComplexity;
+    /**
+     * Extract class metrics
+     */
+    private extractClassMetrics;
+    /**
+     * Create metric value with status
+     */
+    private createMetric;
+    /**
+     * Calculate overall quality score
+     */
+    private calculateQualityScore;
+}
+/**
+ * Create quality metrics calculator instance
+ */
+export declare function createQualityMetricsCalculator(config?: Partial<QualityMetricsConfig>): QualityMetricsCalculator;
+//# sourceMappingURL=quality-metrics.d.ts.map

package/dist/codegen/quality-metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality-metrics.d.ts","sourceRoot":"","sources":["../../src/codegen/quality-metrics.ts"],"names":[],"mappings":"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"}

package/dist/codegen/quality-metrics.js

@@ -0,0 +1,439 @@
+/**
+ * Quality Metrics Calculator
+ *
+ * Calculates code quality metrics
+ *
+ * @packageDocumentation
+ * @module codegen/quality-metrics
+ *
+ * @see REQ-QUA-001 - Quality Metrics
+ * @see Article VI - Quality Standards
+ */
+/**
+ * Default configuration
+ */
+export const DEFAULT_METRICS_CONFIG = {
+    includeTests: false,
+    calculateDuplication: true,
+    duplicationThreshold: 6,
+    complexityThresholds: {
+        good: 10,
+        warning: 20,
+        critical: 30,
+    },
+    maintainabilityThresholds: {
+        good: 80,
+        warning: 60,
+        critical: 40,
+    },
+};
+/**
+ * Quality Metrics Calculator
+ */
+export class QualityMetricsCalculator {
+    config;
+    constructor(config) {
+        this.config = { ...DEFAULT_METRICS_CONFIG, ...config };
+    }
+    /**
+     * Calculate metrics for code
+     */
+    calculate(code, file, language = 'typescript') {
+        const lines = code.split('\n');
+        // Basic line metrics
+        const loc = lines.length;
+        const sloc = this.countSourceLines(lines);
+        const comments = this.countCommentLines(lines, language);
+        const blank = this.countBlankLines(lines);
+        // Complexity metrics
+        const complexity = this.calculateCyclomaticComplexity(code);
+        const maintainability = this.calculateMaintainabilityIndex(loc, complexity, this.calculateHalsteadVolume(code));
+        // Function metrics
+        const functions = this.extractFunctionMetrics(code, language);
+        // Class metrics
+        const classes = this.extractClassMetrics(code, language);
+        return {
+            file,
+            language,
+            metrics: [
+                this.createMetric('loc', loc),
+                this.createMetric('sloc', sloc),
+                this.createMetric('comments', comments),
+                this.createMetric('blank', blank),
+                this.createMetric('complexity', complexity, this.config.complexityThresholds),
+                this.createMetric('maintainability', maintainability, this.config.maintainabilityThresholds),
+            ],
+            functions,
+            classes,
+        };
+    }
+    /**
+     * Calculate metrics for multiple files
+     */
+    calculateProject(files) {
+        const fileMetrics = files.map((f) => this.calculate(f.content, f.path, f.language));
+        const totalFiles = fileMetrics.length;
+        const totalLines = fileMetrics.reduce((sum, f) => sum + (f.metrics.find((m) => m.type === 'loc')?.value ?? 0), 0);
+        const complexities = fileMetrics.map((f) => f.metrics.find((m) => m.type === 'complexity')?.value ?? 0);
+        const averageComplexity = complexities.length > 0
+            ? complexities.reduce((a, b) => a + b, 0) / complexities.length
+            : 0;
+        const maintainabilities = fileMetrics.map((f) => f.metrics.find((m) => m.type === 'maintainability')?.value ?? 0);
+        const averageMaintainability = maintainabilities.length > 0
+            ? maintainabilities.reduce((a, b) => a + b, 0) / maintainabilities.length
+            : 0;
+        // Calculate duplication
+        let duplicationPercentage = 0;
+        if (this.config.calculateDuplication) {
+            const allCode = files.map((f) => f.content).join('\n');
+            duplicationPercentage = this.calculateDuplication(allCode);
+        }
+        // Overall quality score (0-100)
+        const qualityScore = this.calculateQualityScore(averageComplexity, averageMaintainability, duplicationPercentage);
+        return {
+            totalFiles,
+            totalLines,
+            averageComplexity,
+            averageMaintainability,
+            duplicationPercentage,
+            qualityScore,
+            files: fileMetrics,
+        };
+    }
+    /**
+     * Count source lines (non-blank, non-comment)
+     */
+    countSourceLines(lines) {
+        return lines.filter((line) => {
+            const trimmed = line.trim();
+            return trimmed.length > 0 &&
+                !trimmed.startsWith('//') &&
+                !trimmed.startsWith('/*') &&
+                !trimmed.startsWith('*') &&
+                !trimmed.startsWith('#');
+        }).length;
+    }
+    /**
+     * Count comment lines
+     */
+    countCommentLines(lines, _language) {
+        let count = 0;
+        let inBlockComment = false;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (inBlockComment) {
+                count++;
+                if (trimmed.includes('*/')) {
+                    inBlockComment = false;
+                }
+            }
+            else if (trimmed.startsWith('/*')) {
+                count++;
+                if (!trimmed.includes('*/')) {
+                    inBlockComment = true;
+                }
+            }
+            else if (trimmed.startsWith('//') || trimmed.startsWith('#')) {
+                count++;
+            }
+        }
+        return count;
+    }
+    /**
+     * Count blank lines
+     */
+    countBlankLines(lines) {
+        return lines.filter((line) => line.trim().length === 0).length;
+    }
+    /**
+     * Calculate cyclomatic complexity
+     */
+    calculateCyclomaticComplexity(code) {
+        let complexity = 1;
+        const patterns = [
+            /\bif\b/g,
+            /\belse\s+if\b/g,
+            /\bfor\b/g,
+            /\bwhile\b/g,
+            /\bdo\b/g,
+            /\bcase\b/g,
+            /\bcatch\b/g,
+            /\?\?/g,
+            /\?\./g,
+            /&&/g,
+            /\|\|/g,
+            /\?[^:]/g,
+        ];
+        for (const pattern of patterns) {
+            const matches = code.match(pattern);
+            if (matches) {
+                complexity += matches.length;
+            }
+        }
+        return complexity;
+    }
+    /**
+     * Calculate Halstead volume
+     */
+    calculateHalsteadVolume(code) {
+        // Simplified Halstead volume calculation
+        const operators = new Set();
+        const operands = new Set();
+        // Extract operators
+        const opMatches = code.match(/[+\-*/%=<>!&|^~?:]+|\b(function|return|if|else|for|while|class|const|let|var|new|this|typeof|instanceof)\b/g);
+        if (opMatches) {
+            opMatches.forEach((op) => operators.add(op));
+        }
+        // Extract operands (identifiers and literals)
+        const idMatches = code.match(/\b[a-zA-Z_]\w*\b/g);
+        if (idMatches) {
+            idMatches.forEach((id) => operands.add(id));
+        }
+        const n1 = operators.size;
+        const n2 = operands.size;
+        const N1 = opMatches?.length ?? 0;
+        const N2 = idMatches?.length ?? 0;
+        const N = N1 + N2;
+        const n = n1 + n2;
+        if (n === 0)
+            return 0;
+        return N * Math.log2(n);
+    }
+    /**
+     * Calculate maintainability index
+     */
+    calculateMaintainabilityIndex(loc, complexity, halsteadVolume) {
+        // Original MI formula: 171 - 5.2 * ln(V) - 0.23 * CC - 16.2 * ln(LOC)
+        // Scaled to 0-100
+        if (loc === 0 || halsteadVolume === 0)
+            return 100;
+        const mi = 171
+            - 5.2 * Math.log(halsteadVolume + 1)
+            - 0.23 * complexity
+            - 16.2 * Math.log(loc);
+        // Scale to 0-100
+        return Math.max(0, Math.min(100, mi * 100 / 171));
+    }
+    /**
+     * Calculate code duplication percentage
+     */
+    calculateDuplication(code) {
+        const lines = code.split('\n').filter((l) => l.trim().length > 0);
+        if (lines.length === 0)
+            return 0;
+        const threshold = this.config.duplicationThreshold;
+        const duplicatedLines = new Set();
+        // Simple duplication detection using n-gram comparison
+        for (let i = 0; i <= lines.length - threshold; i++) {
+            const chunk = lines.slice(i, i + threshold).join('\n');
+            for (let j = i + threshold; j <= lines.length - threshold; j++) {
+                const compareChunk = lines.slice(j, j + threshold).join('\n');
+                if (chunk === compareChunk) {
+                    for (let k = 0; k < threshold; k++) {
+                        duplicatedLines.add(i + k);
+                        duplicatedLines.add(j + k);
+                    }
+                }
+            }
+        }
+        return (duplicatedLines.size / lines.length) * 100;
+    }
+    /**
+     * Extract function metrics
+     */
+    extractFunctionMetrics(code, _language) {
+        const functions = [];
+        const regex = /(?:function\s+(\w+)|(?:(\w+)\s*[=:]\s*(?:async\s+)?(?:function|\([^)]*\)\s*=>)))/g;
+        let match;
+        while ((match = regex.exec(code)) !== null) {
+            const name = match[1] || match[2];
+            const line = code.substring(0, match.index).split('\n').length;
+            // Find function body
+            const startIndex = match.index;
+            let braceCount = 0;
+            let endIndex = startIndex;
+            let started = false;
+            for (let i = startIndex; i < code.length; i++) {
+                if (code[i] === '{') {
+                    braceCount++;
+                    started = true;
+                }
+                else if (code[i] === '}') {
+                    braceCount--;
+                    if (started && braceCount === 0) {
+                        endIndex = i;
+                        break;
+                    }
+                }
+            }
+            const funcBody = code.substring(startIndex, endIndex + 1);
+            const loc = funcBody.split('\n').length;
+            const complexity = this.calculateCyclomaticComplexity(funcBody);
+            const parameters = this.countParameters(funcBody);
+            const nestingDepth = this.calculateNestingDepth(funcBody);
+            const cognitiveComplexity = this.calculateCognitiveComplexity(funcBody);
+            functions.push({
+                name,
+                line,
+                loc,
+                complexity,
+                parameters,
+                nestingDepth,
+                cognitiveComplexity,
+            });
+        }
+        return functions;
+    }
+    /**
+     * Count function parameters
+     */
+    countParameters(funcBody) {
+        const match = funcBody.match(/\(([^)]*)\)/);
+        if (!match || !match[1].trim())
+            return 0;
+        return match[1].split(',').filter((p) => p.trim()).length;
+    }
+    /**
+     * Calculate nesting depth
+     */
+    calculateNestingDepth(code) {
+        let maxDepth = 0;
+        let currentDepth = 0;
+        for (const char of code) {
+            if (char === '{') {
+                currentDepth++;
+                maxDepth = Math.max(maxDepth, currentDepth);
+            }
+            else if (char === '}') {
+                currentDepth--;
+            }
+        }
+        return maxDepth;
+    }
+    /**
+     * Calculate cognitive complexity
+     */
+    calculateCognitiveComplexity(code) {
+        let complexity = 0;
+        let nesting = 0;
+        const lines = code.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Control flow structures add to complexity based on nesting
+            if (/\b(if|else\s+if|for|while|do|switch|catch)\b/.test(trimmed)) {
+                complexity += 1 + nesting;
+            }
+            // Logical operators add 1
+            const logicalOps = trimmed.match(/&&|\|\|/g);
+            if (logicalOps) {
+                complexity += logicalOps.length;
+            }
+            // Track nesting
+            if (trimmed.includes('{'))
+                nesting++;
+            if (trimmed.includes('}'))
+                nesting = Math.max(0, nesting - 1);
+        }
+        return complexity;
+    }
+    /**
+     * Extract class metrics
+     */
+    extractClassMetrics(code, _language) {
+        const classes = [];
+        const regex = /class\s+(\w+)/g;
+        let match;
+        while ((match = regex.exec(code)) !== null) {
+            const name = match[1];
+            const line = code.substring(0, match.index).split('\n').length;
+            // Find class body
+            const startIndex = code.indexOf('{', match.index);
+            let braceCount = 1;
+            let endIndex = startIndex + 1;
+            while (braceCount > 0 && endIndex < code.length) {
+                if (code[endIndex] === '{')
+                    braceCount++;
+                else if (code[endIndex] === '}')
+                    braceCount--;
+                endIndex++;
+            }
+            const classBody = code.substring(startIndex, endIndex);
+            const loc = classBody.split('\n').length;
+            // Count methods
+            const methodMatches = classBody.match(/(?:async\s+)?(?:static\s+)?(?:get\s+|set\s+)?(\w+)\s*\([^)]*\)\s*[:{]/g);
+            const methodCount = methodMatches?.length ?? 0;
+            // Count properties
+            const propMatches = classBody.match(/(?:private|public|protected|readonly)?\s*(\w+)\s*[?:]?\s*:\s*\w+/g);
+            const propertyCount = propMatches?.length ?? 0;
+            // WMC - sum of complexities of all methods
+            const wmc = this.calculateCyclomaticComplexity(classBody);
+            classes.push({
+                name,
+                line,
+                methodCount,
+                propertyCount,
+                loc,
+                wmc,
+                lcom: 0, // Simplified - would need full analysis
+                dit: 0, // Would need inheritance tree
+                noc: 0, // Would need full codebase
+                cbo: 0, // Would need dependency analysis
+            });
+        }
+        return classes;
+    }
+    /**
+     * Create metric value with status
+     */
+    createMetric(type, value, thresholds) {
+        let status = 'good';
+        if (thresholds) {
+            // For metrics where lower is better (complexity)
+            if (type === 'complexity' || type === 'duplication' || type === 'coupling') {
+                if (value >= thresholds.critical)
+                    status = 'critical';
+                else if (value >= thresholds.warning)
+                    status = 'warning';
+            }
+            // For metrics where higher is better (maintainability, cohesion)
+            else {
+                if (value <= thresholds.critical)
+                    status = 'critical';
+                else if (value <= thresholds.warning)
+                    status = 'warning';
+            }
+        }
+        return {
+            type,
+            value: Math.round(value * 100) / 100,
+            thresholds,
+            status,
+        };
+    }
+    /**
+     * Calculate overall quality score
+     */
+    calculateQualityScore(avgComplexity, avgMaintainability, duplication) {
+        // Weight factors
+        const complexityWeight = 0.3;
+        const maintainabilityWeight = 0.5;
+        const duplicationWeight = 0.2;
+        // Normalize complexity (lower is better, target: 10)
+        const complexityScore = Math.max(0, 100 - (avgComplexity - 10) * 5);
+        // Maintainability is already 0-100
+        const maintainabilityScore = avgMaintainability;
+        // Normalize duplication (lower is better)
+        const duplicationScore = Math.max(0, 100 - duplication * 2);
+        const score = complexityScore * complexityWeight +
+            maintainabilityScore * maintainabilityWeight +
+            duplicationScore * duplicationWeight;
+        return Math.round(Math.max(0, Math.min(100, score)));
+    }
+}
+/**
+ * Create quality metrics calculator instance
+ */
+export function createQualityMetricsCalculator(config) {
+    return new QualityMetricsCalculator(config);
+}
+//# sourceMappingURL=quality-metrics.js.map