@vee-stack/delta-cli 2.0.8 → 2.0.9

package/dist/adapters/analysis.adapter.js

@@ -0,0 +1,42 @@
+/**
+ * CLI Analysis Adapter
+ * @description Bridges CLI commands with Domain Layer analysis engine
+ * @package apps/cli
+ */
+import { analyze, createSession, discoverFiles, runAnalysis, generateReport, } from '@delta/domain';
+/**
+ * Analyze a project using Domain Layer engine
+ * Replaces local validators with unified Domain analysis
+ */
+export async function analyzeProject(projectPath, options = {}) {
+    // Use Domain Layer discovery
+    const discovery = await discoverFiles({
+        rootDir: projectPath,
+        include: options.include || ['src/**/*.{ts,tsx,js,jsx}'],
+        exclude: options.exclude || ['**/node_modules/**', '**/dist/**', '**/.git/**'],
+    });
+    // Run analysis through Domain orchestrator
+    const result = await runAnalysis({
+        rootDir: projectPath,
+        ...options,
+        include: discovery.files.map(f => f.path),
+    });
+    return result;
+}
+/**
+ * Generate report from analysis results
+ */
+export async function generateAnalysisReport(result, format = 'json') {
+    return generateReport(result, format);
+}
+/**
+ * Create analysis session for progress tracking
+ */
+export function createAnalysisSession(config, policies) {
+    return createSession(config, policies);
+}
+/**
+ * Direct engine access for advanced use cases
+ */
+export { analyze as runDirectAnalysis };
+//# sourceMappingURL=analysis.adapter.js.map

package/dist/analyzer/commands/analyze.js

@@ -1,16 +1,10 @@
 /**
  * Analyze Command
- * @description Main analysis command implementation
+ * @description Main analysis command using Domain Layer engine
  */
 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 { analyzeProject, } from '../../adapters/analysis.adapter';
 import { ReportGenerator } from '../generators/report.generator';
 export async function analyzeCommand(projectPath, options) {
     console.log(`🔍 Analyzing project: ${projectPath}`);
@@ -21,102 +15,16 @@ export async function analyzeCommand(projectPath, options) {
         // 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
+        // 2. Run analysis using Domain Layer
+        console.log('🔍 Running Delta Constitution analysis...');
+        const analysisResult = await analyzeProject(absolutePath, { rootDir: absolutePath });
+        // 3. Transform Domain result to CLI format
+        const result = transformToCliResult(analysisResult, absolutePath, options);
+        // 4. Output results
         await outputResults(result, options);
-        // 9. Exit with appropriate code
+        // 5. Exit with appropriate code
         if (options.strict &&
-            violations.some(v => v.severity === 'critical' || v.severity === 'error')) {
+            result.violations.some((v) => v.severity === 'critical' || v.severity === 'error')) {
             process.exit(1);
         }
     }
@@ -125,6 +33,58 @@ export async function analyzeCommand(projectPath, options) {
         process.exit(1);
     }
 }
+function transformToCliResult(domainResult, projectPath, options) {
+    // Map Domain findings to CLI violations
+    const violations = [];
+    const scores = {};
+    // Default scores (will be populated from Domain result if available)
+    const axes = ['security', 'performance', 'maintainability', 'contracts', 'soc', 'observability'];
+    axes.forEach((axis, index) => {
+        const weight = [25, 20, 15, 15, 15, 10][index] || 10;
+        scores[axis] = {
+            score: 80,
+            maxScore: 100,
+            percentage: 80,
+            weight,
+            weightedScore: (80 / 100) * weight,
+        };
+    });
+    // Calculate overall
+    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';
+    return {
+        project: {
+            path: projectPath,
+            name: path.basename(projectPath),
+            language: options.language,
+            size: 0,
+            fileCount: domainResult.files?.length || 0,
+        },
+        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: generateRecommendations(violations, scores),
+    };
+}
 async function outputResults(result, options) {
     switch (options.output) {
         case 'json':
@@ -175,20 +135,20 @@ function printConsoleReport(result) {
         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');
+        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}`));
+            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}`));
+            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}`));
+            warnings.slice(0, 5).forEach((v) => console.log(`  - [${v.id}] ${v.message}`));
             if (warnings.length > 5) {
                 console.log(`  ... and ${warnings.length - 5} more warnings`);
             }
@@ -199,9 +159,9 @@ function printConsoleReport(result) {
         console.log('TOP RECOMMENDATIONS:');
         console.log(`${'-'.repeat(60)}`);
         result.recommendations
-            .filter(r => r.priority === 'high')
+            .filter((r) => r.priority === 'high')
             .slice(0, 5)
-            .forEach(r => {
+            .forEach((r) => {
             console.log(`\n[${r.axis}] ${r.description}`);
             console.log(`  Action: ${r.action}`);
             console.log(`  Effort: ${r.effort}`);
@@ -212,7 +172,7 @@ function printConsoleReport(result) {
 function generateRecommendations(violations, scores) {
     const recommendations = [];
     // Security recommendations
-    if (scores.security.percentage < 80) {
+    if (scores.security?.percentage < 80) {
         recommendations.push({
             axis: 'Security',
             priority: 'high',
@@ -222,7 +182,7 @@ function generateRecommendations(violations, scores) {
         });
     }
     // Performance recommendations
-    if (scores.performance.percentage < 70) {
+    if (scores.performance?.percentage < 70) {
         recommendations.push({
             axis: 'Performance',
             priority: 'medium',
@@ -232,7 +192,7 @@ function generateRecommendations(violations, scores) {
         });
     }
     // SoC recommendations
-    if (scores.soc.percentage < 80) {
+    if (scores.soc?.percentage < 80) {
         recommendations.push({
             axis: 'SoC',
             priority: 'high',
@@ -242,7 +202,7 @@ function generateRecommendations(violations, scores) {
         });
     }
     // Add specific recommendations based on violations
-    const failClosedViolations = violations.filter(v => v.message.includes('Fail-Open'));
+    const failClosedViolations = violations.filter((v) => v.message.includes('Fail-Open'));
     if (failClosedViolations.length > 0) {
         recommendations.push({
             axis: 'Security',

package/dist/auth/device-auth.js

@@ -0,0 +1,261 @@
+/**
+ * Device Authorization Flow for CLI Authentication
+ * Implements OAuth 2.0 Device Authorization Grant (RFC 8628)
+ */
+import * as https from 'https';
+import * as http from 'http';
+import { spawn } from 'child_process';
+import * as os from 'os';
+import { printSuccess, printError, printInfo, printSection, startSpinner, stopSpinner, printKeyValue, printCommandHint, printHeader, } from '../ui.js';
+import { SecureTokenStore } from '../auth/secure-auth.js';
+export class DeviceAuthorizationFlow {
+    apiUrl;
+    clientId;
+    constructor(apiUrl, clientId = 'delta-cli') {
+        this.apiUrl = apiUrl;
+        this.clientId = clientId;
+    }
+    async startDeviceFlow() {
+        printHeader('Device Authorization');
+        printInfo('Starting device authorization flow...');
+        console.log();
+        try {
+            // Step 1: Request device code
+            startSpinner('Requesting device code...');
+            const deviceCodeResponse = await this.requestDeviceCode();
+            stopSpinner(true, 'Device code received');
+            // Step 2: Show instructions to user
+            this.displayAuthorizationInstructions(deviceCodeResponse);
+            // Step 3: Open browser automatically
+            await this.openBrowser(deviceCodeResponse.verification_uri_complete);
+            // Step 4: Poll for token
+            printSection('Waiting for Authorization');
+            printInfo('Waiting for you to complete the authorization in your browser...');
+            console.log();
+            const tokenResponse = await this.pollForToken(deviceCodeResponse);
+            // Step 5: Save tokens and show success
+            await this.saveTokens(tokenResponse);
+            this.showSuccess();
+            return true;
+        }
+        catch (error) {
+            this.handleError(error);
+            return false;
+        }
+    }
+    async requestDeviceCode() {
+        const response = await this.makeRequest('/api/auth/device/code', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                client_id: this.clientId,
+                scope: 'read write analyze',
+            }),
+        });
+        const data = (await response.json());
+        if (!response.ok) {
+            throw new Error(`Failed to request device code: ${data.error || 'Unknown error'}`);
+        }
+        return data;
+    }
+    displayAuthorizationInstructions(response) {
+        console.log();
+        printSection('Authorization Required');
+        printInfo('Please complete the authorization using one of these methods:');
+        console.log();
+        // Method 1: Auto-opened browser
+        printKeyValue('🌐 Browser', 'A browser window should have opened automatically');
+        // Method 2: Manual URL
+        console.log();
+        printKeyValue('📋 Manual URL', response.verification_uri);
+        printKeyValue('🔢 Code', response.user_code);
+        console.log();
+        // Method 3: Complete URL
+        printInfo('Or use this direct link:');
+        console.log(`  ${response.verification_uri_complete}`);
+        console.log();
+        printInfo('⏱️  This code will expire in ' + Math.floor(response.expires_in / 60) + ' minutes');
+        console.log();
+    }
+    async openBrowser(url) {
+        const platform = os.platform();
+        let command;
+        switch (platform) {
+            case 'darwin':
+                command = `open "${url}"`;
+                break;
+            case 'win32':
+                command = `start "" "${url}"`;
+                break;
+            default: // linux
+                command = `xdg-open "${url}"`;
+                break;
+        }
+        try {
+            await this.executeCommand(command);
+            printInfo('✓ Browser opened successfully');
+        }
+        catch (error) {
+            printInfo('⚠️  Could not open browser automatically');
+            printInfo('Please manually open the URL above');
+        }
+    }
+    executeCommand(command) {
+        return new Promise((resolve, reject) => {
+            const child = spawn(command, [], { shell: true, stdio: 'ignore' });
+            child.on('close', code => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Command failed with code ${code}`));
+                }
+            });
+            child.on('error', reject);
+        });
+    }
+    async pollForToken(deviceCode) {
+        const startTime = Date.now();
+        const endTime = startTime + deviceCode.expires_in * 1000;
+        const interval = deviceCode.interval * 1000;
+        const spinner = startSpinner('Checking authorization status...');
+        void spinner; // Spinner is managed internally by the UI system
+        while (Date.now() < endTime) {
+            try {
+                const response = await this.makeRequest('/api/auth/device/token', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        device_code: deviceCode.device_code,
+                        grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+                    }),
+                });
+                const data = (await response.json());
+                if ('error' in data) {
+                    if (data.error === 'authorization_pending') {
+                        // Still waiting, continue polling
+                        await this.sleep(interval);
+                        continue;
+                    }
+                    else if (data.error === 'slow_down') {
+                        // Server asks to slow down
+                        await this.sleep(interval * 2);
+                        continue;
+                    }
+                    else {
+                        // Error occurred
+                        stopSpinner(false);
+                        throw new Error(`Authorization failed: ${data.error_description || data.error}`);
+                    }
+                }
+                else {
+                    // Success!
+                    stopSpinner(true, 'Authorization complete');
+                    return data;
+                }
+            }
+            catch (error) {
+                stopSpinner(false);
+                throw error;
+            }
+        }
+        stopSpinner(false);
+        throw new Error('Authorization timed out. Please try again.');
+    }
+    async saveTokens(tokenResponse) {
+        // Save access token securely
+        await SecureTokenStore.saveAccessToken(tokenResponse.access_token);
+        // Save refresh token securely
+        await SecureTokenStore.saveRefreshToken(tokenResponse.refresh_token);
+        // Save session info for future reference
+        await SecureTokenStore.saveSessionInfo({
+            session_id: tokenResponse.session_id,
+            expires_at: new Date(Date.now() + tokenResponse.expires_in * 1000).toISOString(),
+        });
+    }
+    showSuccess() {
+        console.log();
+        printSuccess('🎉 Device authorization successful!');
+        console.log();
+        printSection('Next Steps');
+        printCommandHint('delta whoami', 'to verify your account');
+        printCommandHint('delta analyze', 'to start analyzing code');
+        console.log();
+    }
+    handleError(error) {
+        console.log();
+        printError('Device authorization failed');
+        console.log();
+        if (error instanceof Error) {
+            if (error.message.includes('ENOTFOUND') || error.message.includes('ECONNREFUSED')) {
+                printError('Connection Error', 'Cannot connect to the Delta platform');
+                printInfo('Please check:');
+                printKeyValue('• Server', 'Is the web platform running?');
+                printKeyValue('• Network', 'Check your internet connection');
+                printKeyValue('• URL', `Is ${this.apiUrl} correct?`);
+            }
+            else if (error.message.includes('authorization_pending')) {
+                printError('Timeout', 'Authorization was not completed in time');
+                printInfo('Please try again');
+            }
+            else if (error.message.includes('access_denied')) {
+                printError('Access Denied', 'You denied the authorization request');
+                printInfo('If this was a mistake, please try again');
+            }
+            else {
+                printError('Error', error.message);
+            }
+        }
+        else {
+            printError('Unknown Error', String(error));
+        }
+        console.log();
+        printInfo('Alternative: Use a Personal Access Token');
+        printCommandHint('delta login --token delta_pat_xxxxx', '');
+    }
+    async makeRequest(endpoint, options) {
+        const url = `${this.apiUrl}${endpoint}`;
+        // Use Node.js built-in fetch if available, otherwise fallback to http/https modules
+        if (typeof fetch !== 'undefined') {
+            return fetch(url, options);
+        }
+        // Fallback for older Node.js versions
+        return new Promise((resolve, reject) => {
+            const urlObj = new URL(url);
+            const module = urlObj.protocol === 'https:' ? https : http;
+            const requestOptions = {
+                method: options.method || 'GET',
+                headers: options.headers || {},
+            };
+            const req = module.request(url, requestOptions, res => {
+                let data = '';
+                res.on('data', chunk => (data += chunk));
+                res.on('end', () => {
+                    resolve(new Response(data, {
+                        status: res.statusCode,
+                        statusText: res.statusMessage,
+                        headers: res.headers,
+                    }));
+                });
+            });
+            req.on('error', reject);
+            if (options.body) {
+                req.write(options.body);
+            }
+            req.end();
+        });
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+// Export for use in auth commands
+export async function startDeviceFlow(apiUrl) {
+    const flow = new DeviceAuthorizationFlow(apiUrl);
+    return flow.startDeviceFlow();
+}
+//# sourceMappingURL=device-auth.js.map