@vee-stack/delta-cli 2.0.3 → 2.0.5

package/dist/packages/domain/src/core/analysis/engine.contract.js

@@ -0,0 +1,298 @@
+/**
+ * Core Analysis Engine - Contract v1 Implementation
+ * @description Stateless pipeline implementing AnalysisEngine contract
+ * @implements AnalysisEngine from @/contracts/analysis.contract.js
+ * @module core/analysis
+ * @version 1.0.0
+ */
+import { ANALYSIS_CONTRACT_VERSION, } from '../../contracts/analysis.contract.js';
+import { rulesRegistry } from '../../control/registry/rules.registry.js';
+// =============================================================================
+// ENGINE IMPLEMENTATION
+// =============================================================================
+/**
+ * Analysis Engine v1.0.0
+ * Implements AnalysisEngine contract
+ */
+export class AnalysisEngineV1 {
+    /** Engine version */
+    version = '1.0.0';
+    /** Supported languages */
+    supportedLanguages = [
+        'typescript',
+        'javascript',
+        'python',
+        'java',
+        'go',
+        'rust',
+        'c',
+        'cpp',
+        'csharp',
+        'php',
+        'ruby',
+        'swift',
+        'kotlin',
+        'sql',
+    ];
+    /**
+     * Analyze a complete project
+     */
+    async analyzeProject(input) {
+        const startTime = Date.now();
+        const fileResults = [];
+        for (const file of input.files) {
+            const result = await this.analyzeFile(file, input.config);
+            fileResults.push(result);
+        }
+        const duration = Date.now() - startTime;
+        const summary = this.summarizeFindings(fileResults);
+        return {
+            id: this.generateId(),
+            timestamp: new Date(),
+            projectId: input.projectId,
+            duration,
+            files: fileResults,
+            summary,
+            engineVersion: this.version,
+            contractVersion: ANALYSIS_CONTRACT_VERSION,
+        };
+    }
+    /**
+     * Analyze a single file
+     */
+    async analyzeFile(file, config) {
+        const startTime = Date.now();
+        // Validate language support
+        if (!this.supportsLanguage(file.language)) {
+            return {
+                filePath: file.path,
+                language: file.language,
+                lines: this.countLines(file.content),
+                findings: [],
+                duration: Date.now() - startTime,
+            };
+        }
+        // Convert to internal format
+        const policies = await this.loadPolicies(config);
+        const findings = this.runAnalysis(file, policies);
+        return {
+            filePath: file.path,
+            language: file.language,
+            lines: this.countLines(file.content),
+            findings,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Check if language is supported
+     */
+    supportsLanguage(language) {
+        return this.supportedLanguages.includes(language.toLowerCase());
+    }
+    /**
+     * Get supported languages
+     */
+    getSupportedLanguages() {
+        return [...this.supportedLanguages];
+    }
+    // =============================================================================
+    // INTERNAL METHODS (Private - not part of contract)
+    // =============================================================================
+    /**
+     * Load policies from config
+     */
+    async loadPolicies(config) {
+        void config;
+        // TODO: Load from policy registry based on config.policies
+        return [];
+    }
+    /**
+     * Run analysis with policies
+     */
+    runAnalysis(file, policies) {
+        const findings = [];
+        void file.content.split('\n');
+        const ruleInput = {
+            file: file.path,
+            content: file.content,
+            language: file.language,
+            project: {
+                root: file.path,
+                config: {},
+            },
+        };
+        // Apply enabled policies
+        for (const policy of policies) {
+            if (!policy.enabled)
+                continue;
+            try {
+                const ruleFindings = rulesRegistry.execute(policy.id, ruleInput, policy);
+                // Convert internal findings to contract format
+                for (const finding of ruleFindings) {
+                    findings.push({
+                        id: this.generateFindingId(),
+                        severity: this.mapSeverity(finding.severity || 'info'),
+                        category: this.mapCategory(policy.category || 'maintainability'),
+                        message: finding.message,
+                        filePath: file.path,
+                        line: finding.location?.line ?? 1,
+                        column: finding.location?.column ?? 0,
+                        endLine: finding.location?.endLine,
+                        endColumn: finding.location?.endColumn,
+                        ruleId: policy.id,
+                        ruleUrl: finding.documentation,
+                        suggestedFix: finding.suggestion
+                            ? {
+                                description: finding.suggestion,
+                            }
+                            : undefined,
+                        metadata: finding.metadata,
+                    });
+                }
+            }
+            catch (error) {
+                // Log but don't fail - one broken rule shouldn't stop analysis
+                console.error(`Policy ${policy.id} failed:`, error);
+            }
+        }
+        return findings;
+    }
+    /**
+     * Summarize findings across all files
+     */
+    summarizeFindings(files) {
+        const bySeverity = {
+            critical: 0,
+            high: 0,
+            medium: 0,
+            low: 0,
+            info: 0,
+        };
+        const byCategory = {
+            security: 0,
+            performance: 0,
+            architecture: 0,
+            maintainability: 0,
+            documentation: 0,
+            testing: 0,
+            style: 0,
+        };
+        let total = 0;
+        for (const file of files) {
+            for (const finding of file.findings) {
+                bySeverity[finding.severity]++;
+                byCategory[finding.category]++;
+                total++;
+            }
+        }
+        return { bySeverity, byCategory, total };
+    }
+    /**
+     * Count lines in content
+     */
+    countLines(content) {
+        return content.split('\n').length;
+    }
+    /**
+     * Map internal severity to contract severity
+     */
+    mapSeverity(severity) {
+        const mapping = {
+            critical: 'critical',
+            error: 'high',
+            warning: 'medium',
+            info: 'info',
+        };
+        return mapping[severity] || 'info';
+    }
+    /**
+     * Map internal category to contract category
+     */
+    mapCategory(category) {
+        const mapping = {
+            security: 'security',
+            performance: 'performance',
+            architecture: 'architecture',
+            maintainability: 'maintainability',
+            documentation: 'documentation',
+            testing: 'testing',
+            style: 'style',
+        };
+        return mapping[category] || 'maintainability';
+    }
+    /**
+     * Generate unique analysis ID
+     */
+    generateId() {
+        return `analysis_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Generate finding ID
+     */
+    generateFindingId() {
+        return `finding_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`;
+    }
+}
+// =============================================================================
+// LEGACY COMPATIBILITY
+// =============================================================================
+/**
+ * Legacy analyze function (maintained for backward compatibility)
+ * @deprecated Use AnalysisEngineV1.analyzeProject instead
+ */
+export function analyze(files, config, policies) {
+    void config;
+    void new AnalysisEngineV1();
+    const startTime = Date.now();
+    const findings = [];
+    for (const file of files) {
+        // Simplified analysis - full implementation uses engine.analyzeFile
+        const fileFindings = runLegacyAnalysis(file.path, file.content, file.language, policies);
+        findings.push(...fileFindings);
+    }
+    return {
+        findings,
+        duration: Date.now() - startTime,
+        filesAnalyzed: files.length,
+    };
+}
+/**
+ * Legacy analysis helper
+ */
+function runLegacyAnalysis(path, content, language, policies) {
+    const findings = [];
+    const ruleInput = {
+        file: path,
+        content,
+        language,
+        project: { root: path, config: {} },
+    };
+    for (const policy of policies) {
+        if (!policy.enabled)
+            continue;
+        try {
+            const ruleFindings = rulesRegistry.execute(policy.id, ruleInput, policy);
+            for (const f of ruleFindings) {
+                findings.push({
+                    id: `legacy_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`,
+                    severity: f.severity || 'info',
+                    category: 'maintainability',
+                    message: f.message,
+                    filePath: path,
+                    line: f.location?.line ?? 1,
+                    column: f.location?.column ?? 0,
+                    ruleId: policy.id,
+                });
+            }
+        }
+        catch {
+            // Ignore errors in legacy mode
+        }
+    }
+    return findings;
+}
+// =============================================================================
+// EXPORTS
+// =============================================================================
+export { ANALYSIS_CONTRACT_VERSION };
+//# sourceMappingURL=engine.contract.js.map

package/dist/packages/domain/src/core/analysis/engine.js

@@ -0,0 +1,77 @@
+/**
+ * Core Analysis Engine
+ * Stateless pipeline for code analysis
+ * @see docs/architecture/OVERVIEW.md#data-flow
+ * @module core/analysis
+ */
+import { rulesRegistry } from '../../control/registry/rules.registry.js';
+/**
+ * Analysis Session
+ * Manages a single analysis run with frozen configuration
+ */
+export class AnalysisSession {
+    context;
+    constructor(config, policies) {
+        this.context = {
+            config: Object.freeze({ ...config }),
+            policies: [...policies],
+            startTime: Date.now(),
+            version: '1.0.0',
+        };
+    }
+    /**
+     * Get immutable context
+     */
+    getContext() {
+        return this.context;
+    }
+    /**
+     * Analyze a single file
+     */
+    analyzeFile(file, content, language) {
+        const ruleInput = {
+            file,
+            content,
+            language,
+            project: {
+                root: this.context.config.version,
+                config: {},
+            },
+        };
+        const findings = [];
+        // Apply all enabled policies
+        for (const policy of this.context.policies) {
+            if (!policy.enabled)
+                continue;
+            const ruleResult = rulesRegistry.execute(policy.id, ruleInput, policy);
+            findings.push(...ruleResult);
+        }
+        return findings;
+    }
+}
+/**
+ * Analysis Pipeline
+ * Pure function: input -> rules -> output
+ */
+export function analyze(files, config, policies) {
+    const startTime = Date.now();
+    const session = new AnalysisSession(config, policies);
+    const allFindings = [];
+    for (const file of files) {
+        const findings = session.analyzeFile(file.path, file.content, file.language);
+        allFindings.push(...findings);
+    }
+    const duration = Date.now() - startTime;
+    return {
+        findings: allFindings,
+        duration,
+        filesAnalyzed: files.length,
+    };
+}
+/**
+ * Create analysis session with frozen snapshot
+ */
+export function createSession(config, policies) {
+    return new AnalysisSession(config, policies);
+}
+//# sourceMappingURL=engine.js.map

package/dist/packages/domain/src/core/analysis/index.js

@@ -0,0 +1,14 @@
+/**
+ * Analysis core index
+ * @description Core analysis engine exports
+ * @version 1.0.0
+ */
+// Contract-based engine (recommended)
+export { AnalysisEngineV1 } from './engine.contract.js';
+// Legacy engine (backward compatibility)
+export { analyze, createSession } from './engine.js';
+// Discovery
+export { discoverFiles, isValidProjectRoot, analyzeProjectTypes, } from './discovery.js';
+// Orchestrator
+export { runAnalysis, generateReport, saveReport, } from './orchestrator.js';
+//# sourceMappingURL=index.js.map

package/dist/packages/domain/src/core/analysis/orchestrator.js

@@ -0,0 +1,242 @@
+/**
+ * Analysis Orchestrator
+ * Coordinates file discovery and AST parsing for complete project analysis
+ */
+import { promises as fs } from 'fs';
+import path from 'path';
+import { discoverFiles } from './discovery.js';
+import { parseSource } from '../parser/unified-parser.js';
+/**
+ * Generate unique analysis ID
+ */
+function generateAnalysisId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 8);
+    return `analysis-${timestamp}-${random}`;
+}
+/**
+ * Run complete project analysis
+ */
+export async function runAnalysis(options) {
+    const startTime = Date.now();
+    const id = generateAnalysisId();
+    // Step 1: Discover files
+    console.log('🔍 Discovering files...');
+    const discoveryOptions = {
+        rootDir: options.rootDir,
+        include: options.include,
+        exclude: options.exclude,
+        maxFileSize: options.maxFileSize,
+    };
+    const discovered = await discoverFiles(discoveryOptions);
+    console.log(`   Found ${discovered.files.length} files (${(discovered.totalSize / 1024 / 1024).toFixed(2)} MB)`);
+    // Step 2: Parse each file
+    console.log('📝 Parsing source files...');
+    const files = [];
+    const errors = [];
+    let totalLines = 0;
+    let totalFunctions = 0;
+    let totalClasses = 0;
+    let totalImports = 0;
+    let totalExports = 0;
+    let totalComplexity = 0;
+    for (let i = 0; i < discovered.files.length; i++) {
+        const file = discovered.files[i];
+        // Progress indicator
+        if (i % 10 === 0 || i === discovered.files.length - 1) {
+            process.stdout.write(`\r   ${i + 1}/${discovered.files.length} files...`);
+        }
+        try {
+            const parseStart = Date.now();
+            const source = await fs.readFile(file.path, 'utf-8');
+            const parseResult = parseSource(source, { filePath: file.path });
+            const duration = Date.now() - parseStart;
+            files.push({
+                file,
+                parseResult,
+                duration,
+            });
+            // Accumulate metrics
+            if (parseResult.success && parseResult.metrics) {
+                totalLines += parseResult.metrics.loc;
+                totalFunctions += parseResult.metrics.functions;
+                totalClasses += parseResult.metrics.classes;
+                totalImports += parseResult.metrics.imports;
+                totalExports += parseResult.metrics.exports;
+                totalComplexity += parseResult.metrics.complexity;
+            }
+            // Collect errors
+            if (!parseResult.success) {
+                errors.push({
+                    file: file.relativePath,
+                    error: parseResult.errors[0]?.message || 'Parse failed',
+                });
+            }
+        }
+        catch (error) {
+            errors.push({
+                file: file.relativePath,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    }
+    console.log('\n✅ Analysis complete!');
+    // Calculate project type
+    const { analyzeProjectTypes } = await import('./discovery.js');
+    const projectType = analyzeProjectTypes(discovered.files);
+    const totalDuration = Date.now() - startTime;
+    const successfulParses = files.filter(f => f.parseResult.success).length;
+    return {
+        id,
+        timestamp: new Date().toISOString(),
+        rootDir: path.resolve(options.rootDir),
+        options,
+        summary: {
+            totalFiles: files.length,
+            successfulParses,
+            failedParses: files.length - successfulParses,
+            totalLines,
+            totalFunctions,
+            totalClasses,
+            totalImports,
+            totalExports,
+            averageComplexity: successfulParses > 0 ? Math.round(totalComplexity / successfulParses) : 0,
+            totalDuration,
+        },
+        files,
+        errors,
+        projectType,
+    };
+}
+/**
+ * Generate report from analysis result
+ */
+export function generateReport(result, format = 'json') {
+    switch (format) {
+        case 'json':
+            return {
+                id: result.id,
+                content: JSON.stringify(result, null, 2),
+                format: 'json',
+            };
+        case 'markdown':
+            return {
+                id: result.id,
+                content: generateMarkdownReport(result),
+                format: 'markdown',
+            };
+        case 'html':
+            return {
+                id: result.id,
+                content: generateHtmlReport(result),
+                format: 'html',
+            };
+        default:
+            throw new Error(`Unknown format: ${format}`);
+    }
+}
+/**
+ * Generate markdown report
+ */
+function generateMarkdownReport(result) {
+    const { summary, projectType, errors } = result;
+    return `# Delta Analysis Report
+
+**Project:** \`${result.rootDir}\`  
+**Generated:** ${new Date(result.timestamp).toLocaleString()}  
+**Analysis ID:** \`${result.id}\`
+
+## Summary
+
+| Metric | Value |
+|--------|-------|
+| Total Files | ${summary.totalFiles} |
+| Successfully Parsed | ${summary.successfulParses} |
+| Failed Parses | ${summary.failedParses} |
+| Total Lines | ${summary.totalLines.toLocaleString()} |
+| Functions | ${summary.totalFunctions.toLocaleString()} |
+| Classes | ${summary.totalClasses.toLocaleString()} |
+| Average Complexity | ${summary.averageComplexity} |
+| Duration | ${(summary.totalDuration / 1000).toFixed(2)}s |
+
+## Project Type
+
+- **JavaScript:** ${projectType.hasJavaScript ? '✅' : '❌'}
+- **TypeScript:** ${projectType.hasTypeScript ? '✅' : '❌'}
+- **React:** ${projectType.hasReact ? '✅' : '❌'}
+- **Vue:** ${projectType.hasVue ? '✅' : '❌'}
+- **Svelte:** ${projectType.hasSvelte ? '✅' : '❌'}
+- **Module Type:** ${projectType.isESM ? 'ESM' : 'CJS'}
+
+## Errors
+
+${errors.length === 0
+        ? 'No errors encountered.'
+        : errors.map((e) => `- **${e.file}:** ${e.error}`).join('\n')}
+
+---
+*Generated by Delta Platform*
+`;
+}
+/**
+ * Generate HTML report
+ */
+function generateHtmlReport(result) {
+    const { summary, projectType } = result;
+    return `<!DOCTYPE html>
+<html>
+<head>
+  <title>Delta Analysis Report</title>
+  <style>
+    body { font-family: system-ui, sans-serif; max-width: 800px; margin: 2rem auto; padding: 0 1rem; }
+    h1 { color: #333; }
+    table { width: 100%; border-collapse: collapse; margin: 1rem 0; }
+    th, td { padding: 0.5rem; text-align: left; border-bottom: 1px solid #ddd; }
+    th { background: #f5f5f5; }
+    .success { color: green; }
+    .error { color: red; }
+  </style>
+</head>
+<body>
+  <h1>Delta Analysis Report</h1>
+  <p><strong>Project:</strong> <code>${result.rootDir}</code></p>
+  <p><strong>Generated:</strong> ${new Date(result.timestamp).toLocaleString()}</p>
+  
+  <h2>Summary</h2>
+  <table>
+    <tr><th>Metric</th><th>Value</th></tr>
+    <tr><td>Total Files</td><td>${summary.totalFiles}</td></tr>
+    <tr><td>Successfully Parsed</td><td class="success">${summary.successfulParses}</td></tr>
+    <tr><td>Failed Parses</td><td class="error">${summary.failedParses}</td></tr>
+    <tr><td>Total Lines</td><td>${summary.totalLines.toLocaleString()}</td></tr>
+    <tr><td>Functions</td><td>${summary.totalFunctions.toLocaleString()}</td></tr>
+    <tr><td>Classes</td><td>${summary.totalClasses.toLocaleString()}</td></tr>
+  </table>
+  
+  <h2>Project Type</h2>
+  <ul>
+    <li>TypeScript: ${projectType.hasTypeScript ? '✅' : '❌'}</li>
+    <li>React: ${projectType.hasReact ? '✅' : '❌'}</li>
+    <li>Vue: ${projectType.hasVue ? '✅' : '❌'}</li>
+  </ul>
+  
+  <footer>
+    <hr>
+    <p><small>Generated by Delta Platform</small></p>
+  </footer>
+</body>
+</html>`;
+}
+/**
+ * Save report to file
+ */
+export async function saveReport(result, outputDir, format = 'json') {
+    const report = generateReport(result, format);
+    const extension = format === 'markdown' ? 'md' : format;
+    const filename = `${result.id}.${extension}`;
+    const filepath = path.join(outputDir, filename);
+    await fs.mkdir(outputDir, { recursive: true });
+    await fs.writeFile(filepath, report.content, 'utf-8');
+    return filepath;
+}
+//# sourceMappingURL=orchestrator.js.map

package/dist/packages/domain/src/core/comparison/engine.js

@@ -0,0 +1,29 @@
+/**
+ * Comparison engine - Core domain logic for code comparison
+ * @see docs/architecture/OVERVIEW.md
+ */
+/**
+ * Comparison engine
+ * Compares analysis results between versions or projects
+ */
+export class ComparisonEngine {
+    /**
+     * Compare two analysis results
+     * @param baseline - Baseline analysis result
+     * @param current - Current analysis result
+     * @returns Comparison result
+     */
+    async compare(baseline, current) {
+        // Implementation placeholder
+        void baseline;
+        void current;
+        return {
+            similarities: 0,
+            differences: 0,
+            additions: 0,
+            deletions: 0,
+            score: 0,
+        };
+    }
+}
+//# sourceMappingURL=engine.js.map

package/dist/packages/domain/src/core/comparison/index.js

@@ -0,0 +1,5 @@
+/**
+ * Comparison core index
+ */
+export { ComparisonEngine } from './engine.js';
+//# sourceMappingURL=index.js.map

package/dist/packages/domain/src/core/documentation/index.js

@@ -0,0 +1,5 @@
+/**
+ * Documentation core index
+ */
+export { DocumentationPipeline } from './pipeline.js';
+//# sourceMappingURL=index.js.map