@vee-stack/delta-cli 2.0.4 → 2.0.6

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

@@ -0,0 +1,40 @@
+/**
+ * Maintainability Validator
+ * @description Validates Maintainability rules
+ */
+export class MaintainabilityValidator {
+    static async validate(project, _options) {
+        const violations = [];
+        let score = 100;
+        // Check for tests
+        const testFiles = project.files.filter(f => f.includes('.test.') || f.includes('.spec.'));
+        const testRatio = testFiles.length / (project.fileCount || 1);
+        if (testRatio < 0.1) {
+            violations.push({
+                id: 'MAINT-TEST-001',
+                severity: 'warning',
+                message: `Low test coverage: ${(testRatio * 100).toFixed(1)}% of files are tests`,
+                rule: 'Testing Required',
+            });
+            score -= 20;
+        }
+        // Check for documentation
+        const hasReadme = project.files.some(f => f.toLowerCase() === 'readme.md' || f.toLowerCase().endsWith('/readme.md'));
+        if (!hasReadme) {
+            violations.push({
+                id: 'MAINT-DOC-001',
+                severity: 'warning',
+                message: 'No README.md found',
+                rule: 'Documentation Required',
+            });
+            score -= 10;
+        }
+        return {
+            score: Math.max(0, score),
+            maxScore: 100,
+            percentage: Math.max(0, score),
+            violations,
+        };
+    }
+}
+//# sourceMappingURL=maintainability.validator.js.map

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

@@ -0,0 +1,39 @@
+/**
+ * Observability Validator
+ * @description Validates Observability rules
+ */
+export class ObservabilityValidator {
+    static async validate(project, _options) {
+        const violations = [];
+        let score = 100;
+        // Check for health endpoint
+        const hasHealthEndpoint = project.files.some(f => f.includes('health') || f.includes('ready') || f.includes('live'));
+        if (!hasHealthEndpoint) {
+            violations.push({
+                id: 'OBS-HEALTH-001',
+                severity: 'warning',
+                message: 'No health check endpoint found',
+                rule: 'Health Checks Required',
+            });
+            score -= 20;
+        }
+        // Check for logging
+        const hasLogging = project.files.some(f => f.includes('logger') || f.includes('log'));
+        if (!hasLogging) {
+            violations.push({
+                id: 'OBS-LOG-001',
+                severity: 'warning',
+                message: 'No logging implementation found',
+                rule: 'Structured Logging Required',
+            });
+            score -= 20;
+        }
+        return {
+            score: Math.max(0, score),
+            maxScore: 100,
+            percentage: Math.max(0, score),
+            violations,
+        };
+    }
+}
+//# sourceMappingURL=observability.validator.js.map

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

@@ -0,0 +1,42 @@
+/**
+ * Performance Validator
+ * @description Validates performance rules
+ */
+export class PerformanceValidator {
+    static async validate(project, _options) {
+        const violations = [];
+        let score = 100;
+        // Check for lazy loading patterns
+        const hasDynamicImports = project.files.some(f => {
+            // Would check file content for dynamic imports
+            return f.includes('dynamic') || f.includes('lazy');
+        });
+        if (!hasDynamicImports && project.fileCount > 50) {
+            violations.push({
+                id: 'PERF-LAZY-001',
+                severity: 'warning',
+                message: 'No lazy loading patterns detected in large project',
+                rule: 'Lazy Loading Recommended',
+            });
+            score -= 10;
+        }
+        // Check for caching implementation
+        const hasCaching = project.files.some(f => f.includes('cache') || f.includes('redis') || f.includes('swr'));
+        if (!hasCaching) {
+            violations.push({
+                id: 'PERF-CACHE-001',
+                severity: 'warning',
+                message: 'No caching implementation found',
+                rule: 'Caching Layer Recommended',
+            });
+            score -= 15;
+        }
+        return {
+            score: Math.max(0, score),
+            maxScore: 100,
+            percentage: Math.max(0, score),
+            violations,
+        };
+    }
+}
+//# sourceMappingURL=performance.validator.js.map

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

@@ -0,0 +1,66 @@
+/**
+ * Security Validator
+ * @description Validates security rules against project
+ */
+export class SecurityValidator {
+    static async validate(project, options) {
+        const violations = [];
+        let score = 100;
+        // Check 1: Policy Registry exists
+        const hasPolicyRegistry = project.directories.some(d => d.includes('modules') && d.includes('policies'));
+        if (!hasPolicyRegistry) {
+            violations.push({
+                id: 'SEC-POL-002',
+                severity: 'error',
+                message: 'Missing policies/ directory in modules',
+                rule: 'Policy Registry Required',
+            });
+            score -= 15;
+        }
+        // Check 2: Audit logging
+        const hasAuditFile = project.files.some(f => f.includes('audit') || f.includes('logger'));
+        if (!hasAuditFile) {
+            violations.push({
+                id: 'SEC-AUDIT-001',
+                severity: 'warning',
+                message: 'No audit logging implementation found',
+                rule: 'Audit Logging Required',
+            });
+            score -= 10;
+        }
+        // Check 3: Rate limiting
+        const hasRateLimit = project.files.some(f => f.includes('rate') || f.includes('limit'));
+        if (!hasRateLimit) {
+            violations.push({
+                id: 'SEC-RATE-001',
+                severity: 'warning',
+                message: 'No rate limiting implementation found',
+                rule: 'Rate Limiting Required',
+            });
+            score -= 10;
+        }
+        // Check 4: Security directory
+        const hasSecurityDir = project.directories.some(d => d.includes('security'));
+        if (!hasSecurityDir) {
+            violations.push({
+                id: 'SEC-DIR-001',
+                severity: 'error',
+                message: 'Missing security/ directory',
+                rule: 'Security Layer Required',
+            });
+            score -= 15;
+        }
+        // Deep scan for Fail-Open patterns (if requested)
+        if (options.depth === 'deep') {
+            // This would scan file contents for fail-open patterns
+            // For now, just check structure
+        }
+        return {
+            score: Math.max(0, score),
+            maxScore: 100,
+            percentage: Math.max(0, score),
+            violations,
+        };
+    }
+}
+//# sourceMappingURL=security.validator.js.map

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

@@ -0,0 +1,75 @@
+/**
+ * SoC Validator
+ * @description Validates Separation of Concerns rules
+ */
+export class SocValidator {
+    static async validate(project, _options) {
+        const violations = [];
+        let score = 100;
+        // Check for proper layer structure
+        const hasFeatures = project.directories.some(d => d.includes('features'));
+        const hasModules = project.directories.some(d => d.includes('modules'));
+        const hasCore = project.directories.some(d => d.includes('core'));
+        const hasContracts = project.directories.some(d => d.includes('contracts'));
+        if (!hasFeatures) {
+            violations.push({
+                id: 'SOC-LAYER-001',
+                severity: 'error',
+                message: 'Missing features/ layer',
+                rule: '7-Layer Architecture',
+            });
+            score -= 20;
+        }
+        if (!hasModules) {
+            violations.push({
+                id: 'SOC-LAYER-002',
+                severity: 'error',
+                message: 'Missing modules/ layer',
+                rule: '7-Layer Architecture',
+            });
+            score -= 20;
+        }
+        if (!hasCore) {
+            violations.push({
+                id: 'SOC-LAYER-003',
+                severity: 'error',
+                message: 'Missing core/ layer',
+                rule: '7-Layer Architecture',
+            });
+            score -= 20;
+        }
+        if (!hasContracts) {
+            violations.push({
+                id: 'SOC-LAYER-004',
+                severity: 'warning',
+                message: 'Missing contracts/ layer',
+                rule: '7-Layer Architecture',
+            });
+            score -= 10;
+        }
+        // Check feature structure
+        if (hasFeatures) {
+            const featureDirs = project.directories.filter(d => d.startsWith('features/'));
+            for (const featureDir of featureDirs) {
+                const hasComponents = project.directories.some(d => d.startsWith(`${featureDir}/components`));
+                const hasHooks = project.directories.some(d => d.startsWith(`${featureDir}/hooks`));
+                if (!hasComponents || !hasHooks) {
+                    violations.push({
+                        id: 'SOC-FEAT-001',
+                        severity: 'warning',
+                        message: `Feature ${featureDir} missing components/ or hooks/`,
+                        rule: 'Feature Structure',
+                    });
+                    score -= 5;
+                }
+            }
+        }
+        return {
+            score: Math.max(0, score),
+            maxScore: 100,
+            percentage: Math.max(0, score),
+            violations,
+        };
+    }
+}
+//# sourceMappingURL=soc.validator.js.map

package/dist/apps/cli/src/analyzer/commands/analyze.js

@@ -0,0 +1,256 @@
+/**
+ * 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/apps/cli/src/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/apps/cli/src/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