@vee-stack/delta-cli 2.0.9 → 2.0.10

package/dist/providers/local-provider.js

@@ -1,304 +0,0 @@
-/**
- * Local Execution Provider
- * Implements all logic locally without external AI services
- */
-import { ExitCode } from '../core/exit-codes.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { loadConfig } from '../commands/auth.js';
-import { SecureTokenStore } from '../auth/secure-auth.js';
-export class LocalProvider {
-    name = 'local';
-    version = '2.0.0';
-    capabilities = {
-        commands: ['analyze', 'init', 'status', 'config', 'auth'],
-        features: {
-            json: true,
-            streaming: false,
-            caching: true,
-            ai: false,
-        },
-        constraints: {
-            maxFileSize: 10 * 1024 * 1024, // 10MB
-            maxFiles: 1000,
-            requiresAuth: false,
-        },
-    };
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    async isAvailable() {
-        // Local provider is always available
-        return true;
-    }
-    async execute(request) {
-        const startTime = Date.now();
-        try {
-            switch (request.type) {
-                case 'analyze':
-                    return await this.executeAnalyze(request);
-                case 'init':
-                    return await this.executeInit(request);
-                case 'status':
-                    return await this.executeStatus(request);
-                case 'config':
-                    return await this.executeConfig(request);
-                case 'auth':
-                    return await this.executeAuth(request);
-                default:
-                    throw new Error(`Task type '${request.type}' not supported by local provider`);
-            }
-        }
-        catch (error) {
-            return {
-                success: false,
-                exitCode: ExitCode.EXECUTION_ERROR,
-                meta: {
-                    command: request.command,
-                    duration: Date.now() - startTime,
-                    timestamp: new Date().toISOString(),
-                    version: this.version,
-                    provider: this.name,
-                },
-                error: {
-                    code: 'LOCAL_EXECUTION_ERROR',
-                    message: error instanceof Error ? error.message : String(error),
-                },
-            };
-        }
-    }
-    // Analyze task execution
-    async executeAnalyze(request) {
-        const { targetPath, options } = request.payload;
-        // Discover files
-        const files = await this.discoverFiles(targetPath, {
-            include: ['**/*.{ts,tsx,js,jsx}'],
-            exclude: this.config.excludePatterns,
-            maxSize: options.maxSize,
-        });
-        // Analyze files
-        const findings = [];
-        let totalLines = 0;
-        let totalFunctions = 0;
-        let totalClasses = 0;
-        for (const file of files) {
-            const content = await fs.readFile(file, 'utf-8');
-            const lines = content.split('\n');
-            totalLines += lines.length;
-            // Simple heuristics
-            if (content.includes('function '))
-                totalFunctions++;
-            if (content.includes('class '))
-                totalClasses++;
-            // Find issues
-            if (content.includes('eval(')) {
-                findings.push({
-                    file: path.relative(targetPath, file),
-                    type: 'security',
-                    severity: 'high',
-                    message: 'Use of eval() detected',
-                });
-            }
-            if (content.includes('console.log')) {
-                findings.push({
-                    file: path.relative(targetPath, file),
-                    type: 'maintainability',
-                    severity: 'low',
-                    message: 'Console.log statement found',
-                });
-            }
-        }
-        // Generate report
-        const report = {
-            schema_version: '1.0',
-            engine_version: this.version,
-            created_at: new Date().toISOString(),
-            project: {
-                name: options.projectName || path.basename(targetPath),
-                path: targetPath,
-            },
-            summary: {
-                total: findings.length,
-                high: findings.filter(f => f.severity === 'high').length,
-                medium: findings.filter(f => f.severity === 'medium').length,
-                low: findings.filter(f => f.severity === 'low').length,
-            },
-            metrics: {
-                totalFiles: files.length,
-                totalLines,
-                totalFunctions,
-                totalClasses,
-            },
-            findings,
-        };
-        // Save report
-        const outputDir = path.resolve(options.output);
-        await fs.mkdir(outputDir, { recursive: true });
-        const reportFile = path.join(outputDir, `report-${Date.now()}.json`);
-        await fs.writeFile(reportFile, JSON.stringify(report, null, 2));
-        return {
-            success: true,
-            exitCode: ExitCode.SUCCESS,
-            meta: {
-                command: request.command,
-                duration: 0,
-                timestamp: new Date().toISOString(),
-                version: this.version,
-                provider: this.name,
-            },
-            data: {
-                report,
-                reportFile,
-                filesAnalyzed: files.length,
-                findings: findings.length,
-            },
-        };
-    }
-    // Init task execution
-    async executeInit(request) {
-        const { projectPath, template } = request.payload;
-        await fs.mkdir(projectPath, { recursive: true });
-        const config = {
-            name: path.basename(projectPath),
-            version: '1.0.0',
-            template,
-            type: 'default',
-            created_at: new Date().toISOString(),
-        };
-        const configPath = path.join(projectPath, 'delta.config.json');
-        await fs.writeFile(configPath, JSON.stringify(config, null, 2));
-        return {
-            success: true,
-            exitCode: ExitCode.SUCCESS,
-            meta: {
-                command: request.command,
-                duration: 0,
-                timestamp: new Date().toISOString(),
-                version: this.version,
-                provider: this.name,
-            },
-            data: {
-                projectPath,
-                configPath,
-                template,
-            },
-        };
-    }
-    // Status task execution
-    async executeStatus(request) {
-        const { projectPath } = request.payload;
-        // Check config
-        const configPath = path.join(projectPath, 'delta.config.json');
-        let hasConfig = false;
-        try {
-            await fs.access(configPath);
-            hasConfig = true;
-        }
-        catch {
-            hasConfig = false;
-        }
-        // Check auth
-        const auth = await loadConfig();
-        const hasPat = await SecureTokenStore.hasTokens();
-        return {
-            success: true,
-            exitCode: ExitCode.SUCCESS,
-            meta: {
-                command: request.command,
-                duration: 0,
-                timestamp: new Date().toISOString(),
-                version: this.version,
-                provider: this.name,
-            },
-            data: {
-                project: {
-                    path: projectPath,
-                    hasConfig,
-                    configPath: hasConfig ? configPath : null,
-                },
-                auth: {
-                    authenticated: hasPat,
-                    apiUrl: auth.apiUrl || 'default',
-                },
-            },
-        };
-    }
-    // Config task execution
-    async executeConfig(request) {
-        // Simple config management
-        return {
-            success: true,
-            exitCode: ExitCode.SUCCESS,
-            meta: {
-                command: request.command,
-                duration: 0,
-                timestamp: new Date().toISOString(),
-                version: this.version,
-                provider: this.name,
-            },
-            data: {
-                action: request.payload.action,
-                config: {},
-            },
-        };
-    }
-    // Auth task execution
-    async executeAuth(request) {
-        const { action } = request.payload;
-        return {
-            success: true,
-            exitCode: ExitCode.SUCCESS,
-            meta: {
-                command: request.command,
-                duration: 0,
-                timestamp: new Date().toISOString(),
-                version: this.version,
-                provider: this.name,
-            },
-            data: {
-                action,
-                authenticated: action === 'login',
-            },
-        };
-    }
-    // File discovery helper
-    async discoverFiles(rootPath, options) {
-        const files = [];
-        async function walk(dir) {
-            const entries = await fs.readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(dir, entry.name);
-                if (entry.isDirectory()) {
-                    if (options.exclude.some(e => entry.name.includes(e)))
-                        continue;
-                    await walk(fullPath);
-                }
-                else if (entry.isFile()) {
-                    // Simple pattern matching
-                    const shouldInclude = options.include.some(pattern => {
-                        if (pattern.includes('**')) {
-                            const ext = pattern.replace('**/*', '');
-                            return entry.name.endsWith(ext);
-                        }
-                        return entry.name.includes(pattern.replace('*', ''));
-                    });
-                    if (shouldInclude) {
-                        try {
-                            const stats = await fs.stat(fullPath);
-                            if (stats.size <= options.maxSize) {
-                                files.push(fullPath);
-                            }
-                        }
-                        catch {
-                            // Skip files we can't stat
-                        }
-                    }
-                }
-            }
-        }
-        await walk(rootPath);
-        return files;
-    }
-}
-//# sourceMappingURL=local-provider.js.map

package/dist/providers/remote-provider.js

@@ -1,100 +0,0 @@
-/**
- * Remote Execution Provider
- * Connects to Delta API for cloud-based execution
- */
-import { ExitCode } from '../core/exit-codes.js';
-import { SecureTokenStore } from '../auth/secure-auth.js';
-export class RemoteProvider {
-    name = 'remote';
-    version = '2.0.0';
-    capabilities = {
-        commands: ['analyze', 'status', 'sync', 'deploy'],
-        features: {
-            json: true,
-            streaming: true,
-            caching: true,
-            ai: false,
-        },
-        constraints: {
-            maxFileSize: 50 * 1024 * 1024, // 50MB
-            maxFiles: 10000,
-            requiresAuth: true,
-        },
-    };
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    async isAvailable() {
-        try {
-            const controller = new AbortController();
-            const timeout = setTimeout(() => controller.abort(), 5000);
-            const response = await fetch(`${this.config.apiUrl}/health`, {
-                method: 'GET',
-                signal: controller.signal,
-            });
-            clearTimeout(timeout);
-            return response.ok;
-        }
-        catch {
-            return false;
-        }
-    }
-    async execute(request) {
-        const startTime = Date.now();
-        try {
-            const pat = await SecureTokenStore.getAccessToken();
-            if (!pat) {
-                throw new Error('Authentication required for remote execution');
-            }
-            // Call remote API
-            const response = await fetch(`${this.config.apiUrl}/api/cli/execute`, {
-                method: 'POST',
-                headers: {
-                    Authorization: `Bearer ${pat}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    type: request.type,
-                    command: request.command,
-                    payload: request.payload,
-                }),
-            });
-            if (!response.ok) {
-                const error = await response.text();
-                throw new Error(`Remote execution failed: ${error}`);
-            }
-            const data = (await response.json());
-            return {
-                success: true,
-                exitCode: ExitCode.SUCCESS,
-                meta: {
-                    command: request.command,
-                    duration: Date.now() - startTime,
-                    timestamp: new Date().toISOString(),
-                    version: this.version,
-                    provider: this.name,
-                },
-                data: data,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                exitCode: ExitCode.NETWORK_ERROR,
-                meta: {
-                    command: request.command,
-                    duration: Date.now() - startTime,
-                    timestamp: new Date().toISOString(),
-                    version: this.version,
-                    provider: this.name,
-                },
-                error: {
-                    code: 'REMOTE_EXECUTION_ERROR',
-                    message: error instanceof Error ? error.message : String(error),
-                },
-            };
-        }
-    }
-}
-//# sourceMappingURL=remote-provider.js.map

package/dist/telemetry/wrapper.js

@@ -1,114 +0,0 @@
-/**
- * CLI Telemetry Wrapper
- * @description Wraps CLI commands with telemetry and error handling
- * @package apps/cli
- */
-import { telemetry, generateCorrelationId, withTelemetry, logCommandMetrics, } from '@delta/infrastructure';
-import { recordCommand, metrics, isDeltaError, getClientErrorMessage } from '@delta/shared';
-/**
- * Wrap a CLI command with telemetry
- */
-export async function withCommandTelemetry(commandName, args, fn) {
-    const correlationId = generateCorrelationId();
-    const startTime = Date.now();
-    const context = {
-        correlationId,
-        requestId: correlationId,
-        path: `cli:${commandName}`,
-        startTime,
-    };
-    return withTelemetry(context, async () => {
-        telemetry.info(`Command started: ${commandName}`, {
-            command: commandName,
-            args: args.join(' '),
-        });
-        try {
-            const result = await fn();
-            const duration = Date.now() - startTime;
-            // Log to telemetry
-            logCommandMetrics({
-                command: commandName,
-                duration,
-                success: true,
-            });
-            // Record to metrics store
-            recordCommand(commandName, duration, true);
-            telemetry.info(`Command completed: ${commandName}`, {
-                command: commandName,
-                duration,
-                success: true,
-            });
-            return result;
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            const errorMessage = getClientErrorMessage(error);
-            // Log to telemetry
-            logCommandMetrics({
-                command: commandName,
-                duration,
-                success: false,
-                error: errorMessage,
-            });
-            // Record to metrics store
-            recordCommand(commandName, duration, false, errorMessage);
-            // Log error details
-            if (isDeltaError(error)) {
-                telemetry.error(`Command failed: ${commandName}`, error, {
-                    command: commandName,
-                    code: error.code,
-                    duration,
-                });
-            }
-            else {
-                telemetry.error(`Command failed: ${commandName}`, error instanceof Error ? error : undefined, {
-                    command: commandName,
-                    duration,
-                });
-            }
-            throw error;
-        }
-    });
-}
-/**
- * Global CLI error handler
- */
-export function handleCliError(error) {
-    if (isDeltaError(error)) {
-        // Structured error - show clean message
-        console.error(`Error [${error.code}]: ${error.message}`);
-        // Show stack in debug mode
-        if (process.env.DEBUG === 'true' || process.env.NODE_ENV === 'development') {
-            console.error('\nDebug info:');
-            console.error(error.toJSON());
-        }
-    }
-    else if (error instanceof Error) {
-        // Regular error
-        console.error(`Error: ${error.message}`);
-        if (process.env.DEBUG === 'true') {
-            console.error(error.stack);
-        }
-    }
-    else {
-        console.error('An unexpected error occurred');
-    }
-}
-/**
- * Print CLI health metrics
- */
-export function printHealthMetrics() {
-    const health = metrics.getHealth();
-    const commandMetrics = metrics.getCommandMetrics(300000); // 5 min
-    console.log('\n📊 CLI Health Metrics');
-    console.log(`Status: ${health.status}`);
-    console.log(`Command Success Rate: ${(health.commandSuccessRate * 100).toFixed(1)}%`);
-    console.log(`Recent Commands: ${commandMetrics.total}`);
-    if (Object.keys(commandMetrics.failuresByCommand).length > 0) {
-        console.log('\n❌ Failures by Command:');
-        Object.entries(commandMetrics.failuresByCommand).forEach(([cmd, count]) => {
-            console.log(`  ${cmd}: ${count}`);
-        });
-    }
-}
-//# sourceMappingURL=wrapper.js.map

package/dist/types/api.js

@@ -1,3 +0,0 @@
-// API Response types for Delta CLI
-export {};
-//# sourceMappingURL=api.js.map