@vee-stack/delta-cli 2.0.8 → 2.0.10

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

@@ -1,298 +0,0 @@
-/**
- * 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

@@ -1,77 +0,0 @@
-/**
- * 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

@@ -1,14 +0,0 @@
-/**
- * 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

@@ -1,242 +0,0 @@
-/**
- * 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

@@ -1,29 +0,0 @@
-/**
- * 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

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

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

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