@vee-stack/delta-cli 2.0.4 → 2.0.6

package/dist/analyzer/commands/analyze.js

@@ -0,0 +1,260 @@
+/**
+ * Analyze Command
+ * @description Main analysis command implementation
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { ProjectScanner } from '../scanners/project.scanner';
+import { SecurityValidator } from '../validators/security.validator';
+import { PerformanceValidator } from '../validators/performance.validator';
+import { SocValidator } from '../validators/soc.validator';
+import { ContractsValidator } from '../validators/contracts.validator';
+import { MaintainabilityValidator } from '../validators/maintainability.validator';
+import { ObservabilityValidator } from '../validators/observability.validator';
+import { ReportGenerator } from '../generators/report.generator';
+export async function analyzeCommand(projectPath, options) {
+    console.log(`🔍 Analyzing project: ${projectPath}`);
+    console.log(`   Language: ${options.language}`);
+    console.log(`   Depth: ${options.depth}`);
+    console.log('');
+    try {
+        // 1. Validate project path
+        const absolutePath = path.resolve(projectPath);
+        await fs.access(absolutePath);
+        // 2. Scan project structure
+        console.log('📁 Scanning project structure...');
+        const projectInfo = await ProjectScanner.scan(absolutePath, options.language);
+        // 3. Run validators
+        console.log('🔒 Validating Security...');
+        const securityResult = await SecurityValidator.validate(projectInfo, options);
+        console.log('⚡ Validating Performance...');
+        const performanceResult = await PerformanceValidator.validate(projectInfo, options);
+        console.log('🏗️ Validating Separation of Concerns...');
+        const socResult = await SocValidator.validate(projectInfo, options);
+        console.log('📋 Validating Contracts...');
+        const contractsResult = await ContractsValidator.validate(projectInfo, options);
+        console.log('🔧 Validating Maintainability...');
+        const maintainabilityResult = await MaintainabilityValidator.validate(projectInfo, options);
+        console.log('👁️ Validating Observability...');
+        const observabilityResult = await ObservabilityValidator.validate(projectInfo, options);
+        // 4. Calculate overall score
+        const scores = {
+            security: {
+                ...securityResult,
+                weight: 25,
+                weightedScore: (securityResult.score / securityResult.maxScore) * 25,
+            },
+            performance: {
+                ...performanceResult,
+                weight: 20,
+                weightedScore: (performanceResult.score / performanceResult.maxScore) * 20,
+            },
+            soc: { ...socResult, weight: 20, weightedScore: (socResult.score / socResult.maxScore) * 20 },
+            contracts: {
+                ...contractsResult,
+                weight: 15,
+                weightedScore: (contractsResult.score / contractsResult.maxScore) * 15,
+            },
+            maintainability: {
+                ...maintainabilityResult,
+                weight: 10,
+                weightedScore: (maintainabilityResult.score / maintainabilityResult.maxScore) * 10,
+            },
+            observability: {
+                ...observabilityResult,
+                weight: 10,
+                weightedScore: (observabilityResult.score / observabilityResult.maxScore) * 10,
+            },
+        };
+        const overallScore = Object.values(scores).reduce((sum, s) => sum + s.weightedScore, 0);
+        const percentage = Math.round(overallScore);
+        const grade = percentage >= 90
+            ? 'A'
+            : percentage >= 80
+                ? 'B'
+                : percentage >= 70
+                    ? 'C'
+                    : percentage >= 60
+                        ? 'D'
+                        : 'F';
+        // 5. Collect violations
+        const violations = [
+            ...securityResult.violations.map(v => ({ ...v, axis: 'Security' })),
+            ...performanceResult.violations.map(v => ({ ...v, axis: 'Performance' })),
+            ...socResult.violations.map(v => ({ ...v, axis: 'SoC' })),
+            ...contractsResult.violations.map(v => ({ ...v, axis: 'Contracts' })),
+            ...maintainabilityResult.violations.map(v => ({ ...v, axis: 'Maintainability' })),
+            ...observabilityResult.violations.map(v => ({ ...v, axis: 'Observability' })),
+        ];
+        // 6. Generate recommendations
+        const recommendations = generateRecommendations(violations, scores);
+        // 7. Build result
+        const result = {
+            project: {
+                path: absolutePath,
+                name: path.basename(absolutePath),
+                language: options.language,
+                size: projectInfo.size,
+                fileCount: projectInfo.fileCount,
+            },
+            timestamp: new Date().toISOString(),
+            constitution: {
+                version: '0.5.0',
+                axes: ['security', 'performance', 'maintainability'],
+            },
+            scores,
+            overall: {
+                score: overallScore,
+                percentage,
+                grade,
+                compliant: violations.filter(v => v.severity === 'critical' || v.severity === 'error').length === 0,
+            },
+            violations,
+            recommendations,
+        };
+        // 8. Output results
+        await outputResults(result, options);
+        // 9. Exit with appropriate code
+        if (options.strict &&
+            violations.some(v => v.severity === 'critical' || v.severity === 'error')) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error('❌ Analysis failed:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+async function outputResults(result, options) {
+    switch (options.output) {
+        case 'json':
+            console.log(JSON.stringify(result, null, 2));
+            break;
+        case 'html':
+            {
+                const html = ReportGenerator.generateHTML(result);
+                const htmlPath = `${result.project.name}-analysis.html`;
+                await fs.writeFile(htmlPath, html);
+                console.log(`📄 HTML report saved to: ${htmlPath}`);
+            }
+            break;
+        case 'markdown':
+            {
+                const markdown = ReportGenerator.generateMarkdown(result);
+                const mdPath = `${result.project.name}-analysis.md`;
+                await fs.writeFile(mdPath, markdown);
+                console.log(`📄 Markdown report saved to: ${mdPath}`);
+            }
+            break;
+        default:
+            // Console output
+            printConsoleReport(result);
+    }
+}
+function printConsoleReport(result) {
+    console.log('\n' + '='.repeat(60));
+    console.log('📊 DELTA CONSTITUTION ANALYSIS REPORT');
+    console.log('='.repeat(60));
+    console.log(`\nProject: ${result.project.name}`);
+    console.log(`Path: ${result.project.path}`);
+    console.log(`Language: ${result.project.language}`);
+    console.log(`Files: ${result.project.fileCount}`);
+    console.log(`Constitution: v${result.constitution.version}`);
+    console.log(`\n${'-'.repeat(60)}`);
+    console.log(`\n🎯 OVERALL SCORE: ${result.overall.percentage}% (Grade: ${result.overall.grade})`);
+    console.log(`Status: ${result.overall.compliant ? '✅ Compliant' : '❌ Non-Compliant'}`);
+    console.log(`\n${'-'.repeat(60)}`);
+    console.log('AXIS SCORES:');
+    console.log(`${'-'.repeat(60)}`);
+    Object.entries(result.scores).forEach(([axis, score]) => {
+        const bar = '█'.repeat(Math.round(score.percentage / 5)) +
+            '░'.repeat(20 - Math.round(score.percentage / 5));
+        console.log(`${axis.padEnd(20)} ${bar} ${score.percentage.toString().padStart(3)}%`);
+    });
+    if (result.violations.length > 0) {
+        console.log(`\n${'-'.repeat(60)}`);
+        console.log('VIOLATIONS:');
+        console.log(`${'-'.repeat(60)}`);
+        const critical = result.violations.filter(v => v.severity === 'critical');
+        const errors = result.violations.filter(v => v.severity === 'error');
+        const warnings = result.violations.filter(v => v.severity === 'warning');
+        if (critical.length > 0) {
+            console.log('\n🔴 Critical:');
+            critical.forEach(v => console.log(`  - [${v.id}] ${v.message}`));
+        }
+        if (errors.length > 0) {
+            console.log('\n🟠 Errors:');
+            errors.forEach(v => console.log(`  - [${v.id}] ${v.message}`));
+        }
+        if (warnings.length > 0) {
+            console.log('\n🟡 Warnings:');
+            warnings.slice(0, 5).forEach(v => console.log(`  - [${v.id}] ${v.message}`));
+            if (warnings.length > 5) {
+                console.log(`  ... and ${warnings.length - 5} more warnings`);
+            }
+        }
+    }
+    if (result.recommendations.length > 0) {
+        console.log(`\n${'-'.repeat(60)}`);
+        console.log('TOP RECOMMENDATIONS:');
+        console.log(`${'-'.repeat(60)}`);
+        result.recommendations
+            .filter(r => r.priority === 'high')
+            .slice(0, 5)
+            .forEach(r => {
+            console.log(`\n[${r.axis}] ${r.description}`);
+            console.log(`  Action: ${r.action}`);
+            console.log(`  Effort: ${r.effort}`);
+        });
+    }
+    console.log('\n' + '='.repeat(60) + '\n');
+}
+function generateRecommendations(violations, scores) {
+    const recommendations = [];
+    // Security recommendations
+    if (scores.security.percentage < 80) {
+        recommendations.push({
+            axis: 'Security',
+            priority: 'high',
+            description: 'Security score below 80%',
+            action: 'Implement Policy Guards, Audit Logging, and Fail-Closed patterns',
+            effort: '2-3 days',
+        });
+    }
+    // Performance recommendations
+    if (scores.performance.percentage < 70) {
+        recommendations.push({
+            axis: 'Performance',
+            priority: 'medium',
+            description: 'Performance optimizations needed',
+            action: 'Add lazy loading, code splitting, and caching layers',
+            effort: '1-2 days',
+        });
+    }
+    // SoC recommendations
+    if (scores.soc.percentage < 80) {
+        recommendations.push({
+            axis: 'SoC',
+            priority: 'high',
+            description: 'Layer boundaries need improvement',
+            action: 'Refactor to follow 7-layer architecture, fix import violations',
+            effort: '3-5 days',
+        });
+    }
+    // Add specific recommendations based on violations
+    const failClosedViolations = violations.filter(v => v.message.includes('Fail-Open'));
+    if (failClosedViolations.length > 0) {
+        recommendations.push({
+            axis: 'Security',
+            priority: 'high',
+            description: `Found ${failClosedViolations.length} Fail-Open patterns`,
+            action: 'Replace with Fail-Closed: if (!isAllowed) return deny()',
+            effort: '1 day',
+        });
+    }
+    return recommendations.sort((a, b) => {
+        const priorityOrder = { high: 0, medium: 1, low: 2 };
+        return priorityOrder[a.priority] - priorityOrder[b.priority];
+    });
+}
+//# sourceMappingURL=analyze.js.map

package/dist/analyzer/commands/config.js

@@ -0,0 +1,83 @@
+/**
+ * Config Command
+ * @description Manage analyzer configuration
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+const DEFAULT_CONFIG = {
+    version: '1.0.0',
+    language: 'typescript',
+    depth: 'standard',
+    output: 'json',
+    strict: false,
+    rules: {
+        security: { enabled: true, weight: 25 },
+        performance: { enabled: true, weight: 20 },
+        soc: { enabled: true, weight: 20 },
+        contracts: { enabled: true, weight: 15 },
+        maintainability: { enabled: true, weight: 10 },
+        observability: { enabled: true, weight: 10 },
+    },
+    thresholds: {
+        critical: 0,
+        error: 5,
+        warning: 20,
+    },
+};
+export async function configCommand(options) {
+    const configPath = path.join(process.cwd(), '.delta-analyzer.json');
+    if (options.init) {
+        try {
+            await fs.writeFile(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2));
+            console.log('✅ Configuration file created: .delta-analyzer.json');
+            console.log('\nEdit this file to customize analyzer settings.');
+        }
+        catch (error) {
+            console.error('❌ Failed to create config:', error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+        return;
+    }
+    if (options.show) {
+        try {
+            const content = await fs.readFile(configPath, 'utf-8');
+            const config = JSON.parse(content);
+            console.log('\n📋 Current Configuration:\n');
+            console.log(JSON.stringify(config, null, 2));
+        }
+        catch {
+            console.log('⚠️ No configuration file found. Run with --init to create one.');
+        }
+        return;
+    }
+    if (options.set) {
+        const [key, value] = options.set.split('=');
+        if (!key || !value) {
+            console.error('❌ Invalid format. Use: --set key=value');
+            process.exit(1);
+        }
+        try {
+            const content = await fs.readFile(configPath, 'utf-8');
+            const config = JSON.parse(content);
+            // Simple nested key support (e.g., "rules.security.enabled")
+            const keys = key.split('.');
+            let current = config;
+            for (let i = 0; i < keys.length - 1; i++) {
+                current = current[keys[i]];
+            }
+            current[keys[keys.length - 1]] = value;
+            await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+            console.log(`✅ Set ${key} = ${value}`);
+        }
+        catch {
+            console.log('⚠️ No configuration file found. Run with --init to create one.');
+            process.exit(1);
+        }
+        return;
+    }
+    console.log('Usage:');
+    console.log('  delta-analyze config --init    Create default configuration');
+    console.log('  delta-analyze config --show    Show current configuration');
+    console.log('  delta-analyze config --set key=value  Set configuration value');
+}
+//# sourceMappingURL=config.js.map

package/dist/analyzer/commands/report.js

@@ -0,0 +1,38 @@
+/**
+ * Report Command
+ * @description Generate report from previous analysis
+ */
+import * as fs from 'fs/promises';
+import { ReportGenerator } from '../generators/report.generator';
+export async function reportCommand(analysisFile, options) {
+    try {
+        // Read analysis file
+        const content = await fs.readFile(analysisFile, 'utf-8');
+        const analysis = JSON.parse(content);
+        // Generate report
+        let output;
+        let extension;
+        switch (options.template) {
+            case 'html':
+                output = ReportGenerator.generateHTML(analysis);
+                extension = 'html';
+                break;
+            case 'markdown':
+                output = ReportGenerator.generateMarkdown(analysis);
+                extension = 'md';
+                break;
+            default:
+                console.error(`Unknown template: ${options.template}`);
+                process.exit(1);
+        }
+        // Write to file
+        const outputPath = options.output || `${analysis.project.name}-report.${extension}`;
+        await fs.writeFile(outputPath, output);
+        console.log(`✅ Report generated: ${outputPath}`);
+    }
+    catch (error) {
+        console.error('❌ Failed to generate report:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=report.js.map

package/dist/analyzer/generators/report.generator.js

@@ -0,0 +1,123 @@
+/**
+ * Report Generator
+ * @description Generates analysis reports in various formats
+ */
+export class ReportGenerator {
+    static generateHTML(result) {
+        return `<!DOCTYPE html>
+<html>
+<head>
+  <title>Delta Analysis - ${result.project.name}</title>
+  <style>
+    body { font-family: system-ui, sans-serif; max-width: 900px; margin: 0 auto; padding: 20px; }
+    .header { background: #1a1a2e; color: white; padding: 30px; border-radius: 8px; margin-bottom: 20px; }
+    .score { font-size: 48px; font-weight: bold; }
+    .grade { font-size: 24px; opacity: 0.8; }
+    .axis { background: #f5f5f5; padding: 15px; margin: 10px 0; border-radius: 6px; }
+    .bar { background: #ddd; height: 20px; border-radius: 10px; overflow: hidden; }
+    .bar-fill { background: #4CAF50; height: 100%; transition: width 0.3s; }
+    .violation { padding: 10px; margin: 5px 0; border-left: 4px solid; }
+    .critical { border-color: #f44336; background: #ffebee; }
+    .error { border-color: #ff9800; background: #fff3e0; }
+    .warning { border-color: #ffeb3b; background: #fffde7; }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <h1>📊 Delta Constitution Analysis</h1>
+    <div class="score">${result.overall.percentage}%</div>
+    <div class="grade">Grade: ${result.overall.grade}</div>
+    <p>Project: ${result.project.name} | ${result.project.fileCount} files</p>
+  </div>
+  
+  <h2>Axis Scores</h2>
+  ${Object.entries(result.scores)
+            .map(([name, score]) => `
+    <div class="axis">
+      <strong>${name}</strong>: ${score.percentage}%
+      <div class="bar"><div class="bar-fill" style="width: ${score.percentage}%"></div></div>
+    </div>
+  `)
+            .join('')}
+  
+  <h2>Violations (${result.violations.length})</h2>
+  ${result.violations
+            .slice(0, 20)
+            .map(v => `
+    <div class="violation ${v.severity}">
+      <strong>[${v.axis}] ${v.id}</strong>: ${v.message}
+    </div>
+  `)
+            .join('')}
+  
+  <h2>Recommendations</h2>
+  ${result.recommendations
+            .slice(0, 5)
+            .map(r => `
+    <div class="axis">
+      <strong>[${r.axis}] ${r.priority}</strong>
+      <p>${r.description}</p>
+      <small>Action: ${r.action}</small>
+    </div>
+  `)
+            .join('')}
+  
+  <footer style="margin-top: 40px; padding-top: 20px; border-top: 1px solid #ddd; color: #666;">
+    Generated: ${result.timestamp} | Delta Constitution v1.0.0
+  </footer>
+</body>
+</html>`;
+    }
+    static generateMarkdown(result) {
+        return `# Delta Constitution Analysis Report
+
+## Project: ${result.project.name}
+
+- **Path**: ${result.project.path}
+- **Language**: ${result.project.language}
+- **Files**: ${result.project.fileCount}
+- **Generated**: ${result.timestamp}
+
+---
+
+## Overall Score: ${result.overall.percentage}% (Grade: ${result.overall.grade})
+
+**Status**: ${result.overall.compliant ? '✅ Compliant' : '❌ Non-Compliant'}
+
+---
+
+## Axis Scores
+
+| Axis | Score | Weight | Status |
+|------|-------|--------|--------|
+${Object.entries(result.scores)
+            .map(([name, s]) => `| ${name} | ${s.percentage}% | ${s.weight}% | ${s.percentage >= 70 ? '✅' : '⚠️'} |`)
+            .join('\n')}
+
+---
+
+## Violations (${result.violations.length})
+
+${result.violations
+            .slice(0, 30)
+            .map(v => `- **[${v.axis}]** \`${v.id}\` (${v.severity}): ${v.message}`)
+            .join('\n')}
+
+---
+
+## Top Recommendations
+
+${result.recommendations
+            .slice(0, 10)
+            .map((r, i) => `${i + 1}. **[${r.axis}]** ${r.description}
+   - Priority: ${r.priority}
+   - Action: ${r.action}`)
+            .join('\n\n')}
+
+---
+
+*Report generated by Delta Analyzer v1.0.0*
+`;
+    }
+}
+//# sourceMappingURL=report.generator.js.map

package/dist/analyzer/index.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+/**
+ * Delta CLI Analyzer
+ * @description Analyze projects against Delta Constitution
+ * @version 1.0.0
+ */
+import { Command } from 'commander';
+import { analyzeCommand } from './commands/analyze';
+import { reportCommand } from './commands/report';
+import { configCommand } from './commands/config';
+const program = new Command();
+program
+    .name('delta-analyze')
+    .description('Analyze projects against Delta Constitution')
+    .version('1.0.0');
+// Analyze command
+program
+    .command('analyze')
+    .description('Analyze a project against Delta Constitution')
+    .argument('<path>', 'Project path to analyze')
+    .option('-l, --language <lang>', 'Project language', 'typescript')
+    .option('-o, --output <format>', 'Output format (json|html|markdown)', 'json')
+    .option('-d, --depth <level>', 'Analysis depth (quick|standard|deep)', 'standard')
+    .option('--config <path>', 'Configuration file path')
+    .option('--strict', 'Fail on any violation', false)
+    .action(analyzeCommand);
+// Report command
+program
+    .command('report')
+    .description('Generate report from previous analysis')
+    .argument('<analysis-file>', 'Previous analysis JSON file')
+    .option('-t, --template <type>', 'Report template (html|markdown|pdf)', 'html')
+    .option('-o, --output <path>', 'Output file path')
+    .action(reportCommand);
+// Config command
+program
+    .command('config')
+    .description('Manage analyzer configuration')
+    .option('--init', 'Initialize configuration file')
+    .option('--show', 'Show current configuration')
+    .option('--set <key=value>', 'Set configuration value')
+    .action(configCommand);
+program.parse();
+//# sourceMappingURL=index.js.map

package/dist/analyzer/scanners/project.scanner.js

@@ -0,0 +1,92 @@
+/**
+ * Project Scanner
+ * @description Scans project structure and extracts metadata
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export class ProjectScanner {
+    static async scan(projectPath, language) {
+        const files = [];
+        const directories = [];
+        const totalSize = 0;
+        // Scan directory recursively
+        await this.scanDirectory(projectPath, '', files, directories, totalSize);
+        // Detect project metadata
+        const hasPackageJson = files.some(f => f.endsWith('package.json'));
+        const hasTsConfig = files.some(f => f.endsWith('tsconfig.json'));
+        const hasTests = files.some(f => f.includes('.test.') || f.includes('.spec.'));
+        // Extract imports
+        const imports = await this.extractImports(files, projectPath);
+        return {
+            path: projectPath,
+            name: path.basename(projectPath),
+            language,
+            size: totalSize,
+            fileCount: files.length,
+            files,
+            directories,
+            imports,
+            hasPackageJson,
+            hasTsConfig,
+            hasTests,
+        };
+    }
+    static async scanDirectory(basePath, relativePath, files, directories, totalSize) {
+        const fullPath = path.join(basePath, relativePath);
+        try {
+            const entries = await fs.readdir(fullPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const entryRelativePath = path.join(relativePath, entry.name);
+                // Skip node_modules and hidden directories
+                if (entry.name === 'node_modules' || entry.name.startsWith('.')) {
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    directories.push(entryRelativePath);
+                    await this.scanDirectory(basePath, entryRelativePath, files, directories, totalSize);
+                }
+                else if (entry.isFile()) {
+                    // Only include source files
+                    if (this.isSourceFile(entry.name)) {
+                        files.push(entryRelativePath);
+                        const stats = await fs.stat(path.join(fullPath, entry.name));
+                        totalSize += stats.size;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Directory not accessible, skip
+        }
+    }
+    static isSourceFile(filename) {
+        const extensions = ['.ts', '.tsx', '.js', '.jsx', '.json', '.md'];
+        return extensions.some(ext => filename.endsWith(ext));
+    }
+    static async extractImports(files, projectPath) {
+        const imports = [];
+        for (const file of files) {
+            if (!file.endsWith('.ts') && !file.endsWith('.tsx'))
+                continue;
+            try {
+                const content = await fs.readFile(path.join(projectPath, file), 'utf-8');
+                const importMatches = content.match(/import\s+.*?\s+from\s+['"]([^'"]+)['"];?/g) || [];
+                for (const match of importMatches) {
+                    const importPath = match.match(/from\s+['"]([^'"]+)['"]/)?.[1];
+                    if (importPath) {
+                        imports.push({
+                            source: file,
+                            target: importPath,
+                            type: importPath.startsWith('.') ? 'internal' : 'external',
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                // Skip files that can't be read
+            }
+        }
+        return imports;
+    }
+}
+//# sourceMappingURL=project.scanner.js.map

package/dist/analyzer/validators/contracts.validator.js

@@ -0,0 +1,42 @@
+/**
+ * Contracts Validator
+ * @description Validates Contracts rules
+ */
+export class ContractsValidator {
+    static async validate(project, _options) {
+        const violations = [];
+        let score = 100;
+        // Check for contract files
+        const contractFiles = project.files.filter(f => f.includes('.contract.'));
+        if (contractFiles.length === 0) {
+            violations.push({
+                id: 'CONTRACT-001',
+                severity: 'error',
+                message: 'No contract files found',
+                rule: 'Contracts Required',
+            });
+            score -= 30;
+        }
+        // Check for required contracts
+        const requiredContracts = ['auth', 'upload', 'projects', 'analysis'];
+        for (const contract of requiredContracts) {
+            const hasContract = contractFiles.some(f => f.includes(`${contract}.contract`));
+            if (!hasContract) {
+                violations.push({
+                    id: 'CONTRACT-002',
+                    severity: 'warning',
+                    message: `Missing ${contract}.contract.ts`,
+                    rule: 'Required Contracts',
+                });
+                score -= 10;
+            }
+        }
+        return {
+            score: Math.max(0, score),
+            maxScore: 100,
+            percentage: Math.max(0, score),
+            violations,
+        };
+    }
+}
+//# sourceMappingURL=contracts.validator.js.map