@vee-stack/delta-cli 2.0.4 → 2.0.5

package/dist/apps/cli/src/plugins/GitStatusPlugin.js

@@ -0,0 +1,99 @@
+/**
+ * GitStatusPlugin - MVP Plugin Example
+ * Displays git repository status in the sidebar
+ * Demonstrates Plugin System capabilities
+ */
+import { execSync } from 'child_process';
+export class GitStatusPlugin {
+    id = 'git-status';
+    name = 'Git Status';
+    version = '1.0.0';
+    description = 'Displays git repository status in the dashboard';
+    context;
+    branch = 'unknown';
+    status = 'clean';
+    aheadBehind = '';
+    constructor(context) {
+        this.context = context;
+    }
+    onActivate() {
+        this.updateGitStatus();
+        // Auto-update every 10 seconds
+        setInterval(() => this.updateGitStatus(), 10000);
+        this.context.addLog('GitStatus', 'Git Status Plugin activated', 'info');
+    }
+    onDeactivate() {
+        this.context.addLog('GitStatus', 'Git Status Plugin deactivated', 'info');
+    }
+    registerCommands() {
+        return [
+            {
+                id: 'refresh',
+                label: 'Refresh Git Status',
+                shortcut: 'g',
+                icon: '🔄',
+                execute: () => {
+                    this.updateGitStatus();
+                    this.context.addLog('GitStatus', 'Git status refreshed manually', 'success');
+                },
+            },
+        ];
+    }
+    registerDashboardWidgets() {
+        return [
+            {
+                id: 'git-info',
+                title: 'Git Status',
+                position: 'sidebar',
+                priority: 10,
+                render: () => this.renderWidget(),
+                updateInterval: 10000,
+            },
+        ];
+    }
+    updateGitStatus() {
+        try {
+            // Check if we're in a git repo
+            execSync('git rev-parse --git-dir', { stdio: 'pipe' });
+            // Get current branch
+            this.branch = execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
+            // Check for uncommitted changes
+            const status = execSync('git status --porcelain', { encoding: 'utf-8' });
+            this.status = status.trim() ? 'dirty' : 'clean';
+            // Get ahead/behind info
+            try {
+                const aheadBehind = execSync('git rev-list --left-right --count HEAD...@{u} 2>/dev/null || echo "0\t0"', { encoding: 'utf-8' }).trim();
+                const [ahead, behind] = aheadBehind.split('\t');
+                if (ahead !== '0' || behind !== '0') {
+                    this.aheadBehind = `${ahead}↑ ${behind}↓`;
+                }
+                else {
+                    this.aheadBehind = '';
+                }
+            }
+            catch {
+                this.aheadBehind = '';
+            }
+        }
+        catch {
+            this.branch = 'not a repo';
+            this.status = 'clean';
+            this.aheadBehind = '';
+        }
+    }
+    renderWidget() {
+        const { Text, Box } = require('ink');
+        const statusIcon = this.status === 'clean' ? '✓' : '⚡';
+        const statusColor = this.status === 'clean' ? 'green' : 'yellow';
+        return (Box({
+            flexDirection: 'column',
+            borderStyle: 'round',
+            borderColor: 'gray',
+            paddingX: 1,
+            width: 28,
+            marginBottom: 1,
+        }, Text({ bold: true, color: 'cyan' }, '🌿 Git Status'), Text({ color: 'white' }, `Branch: ${this.branch}`), Text({ color: statusColor }, `${statusIcon} ${this.status === 'clean' ? 'Clean' : 'Modified'}`), this.aheadBehind ? Text({ color: 'yellow' }, this.aheadBehind) : null));
+    }
+}
+export default GitStatusPlugin;
+//# sourceMappingURL=GitStatusPlugin.js.map

package/dist/apps/cli/src/providers/ai-provider.js

@@ -0,0 +1,74 @@
+/**
+ * AI Provider (Placeholder)
+ * Reserved for future AI integration without breaking existing architecture
+ */
+import { ExitCode } from '../core/exit-codes.js';
+export class AIProviderPlaceholder {
+    name = 'ai';
+    version = '2.0.0-placeholder';
+    capabilities = {
+        commands: ['analyze'],
+        features: {
+            json: true,
+            streaming: true,
+            caching: false,
+            ai: true,
+        },
+        constraints: {
+            maxFileSize: 100 * 1024 * 1024, // 100MB
+            requiresAuth: true,
+        },
+    };
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async isAvailable() {
+        // AI provider is not available in current version
+        // This will return true when AI is implemented
+        return this.config.enabled && !!this.config.apiKey;
+    }
+    async execute(request) {
+        const startTime = Date.now();
+        // Placeholder: Return error indicating AI is not implemented
+        return {
+            success: false,
+            exitCode: ExitCode.POLICY_BLOCKED,
+            meta: {
+                command: request.command,
+                duration: Date.now() - startTime,
+                timestamp: new Date().toISOString(),
+                version: this.version,
+                provider: this.name,
+            },
+            error: {
+                code: 'AI_NOT_IMPLEMENTED',
+                message: 'AI features are reserved for future releases. Use --provider=local for now.',
+                details: {
+                    note: 'AI integration will be available in v2.1.0 without requiring any CLI changes',
+                    alternative: 'Use --provider=local for local execution or --provider=remote for cloud execution',
+                },
+            },
+        };
+    }
+    // AI-specific methods (to be implemented)
+    async generate(input, _context) {
+        if (!this.config.enabled) {
+            throw new Error('AI provider is not enabled');
+        }
+        // Placeholder implementation
+        return `AI generation not implemented. Input received: ${input.substring(0, 50)}...`;
+    }
+    async analyzeCode(_code, _language) {
+        if (!this.config.enabled) {
+            throw new Error('AI provider is not enabled');
+        }
+        // Placeholder implementation
+        return {
+            insights: ['AI code analysis not yet implemented'],
+            suggestions: ['Use --provider=local for current analysis capabilities'],
+            score: 0,
+        };
+    }
+}
+//# sourceMappingURL=ai-provider.js.map

package/dist/apps/cli/src/providers/local-provider.js

@@ -0,0 +1,302 @@
+/**
+ * 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';
+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();
+        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: !!auth.pat,
+                    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/apps/cli/src/providers/remote-provider.js

@@ -0,0 +1,100 @@
+/**
+ * Remote Execution Provider
+ * Connects to Delta API for cloud-based execution
+ */
+import { ExitCode } from '../core/exit-codes.js';
+import { loadConfig } from '../commands/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 auth = await loadConfig();
+            if (!auth.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 ${auth.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/apps/cli/src/types/api.js

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