@vee-stack/delta-cli 2.0.8 → 2.0.10

package/dist/packages/domain/src/rules/index.js

@@ -1,134 +0,0 @@
-/**
- * Rules Implementation - First Rule Engine
- * Concrete rule implementations using pure functions
- * @module rules
- */
-import { rulesRegistry } from '../control/registry/rules.registry.js';
-/**
- * File Size Rule
- * Checks if file exceeds maximum size
- */
-const fileSizeRule = (input, policy) => {
-    if (policy.type !== 'file-size')
-        return [];
-    const contentSizeKB = Buffer.byteLength(input.content, 'utf8') / 1024;
-    const findings = [];
-    if (policy.maxSizeKB && contentSizeKB > policy.maxSizeKB) {
-        findings.push({
-            id: `file-size-${input.file}`,
-            ruleId: policy.id,
-            severity: policy.severity,
-            category: policy.category,
-            message: `File size (${contentSizeKB.toFixed(2)} KB) exceeds maximum (${policy.maxSizeKB} KB)`,
-            filePath: input.file,
-            line: 1,
-            column: 1,
-            suggestion: 'Consider splitting this file into smaller modules',
-            relatedFindings: [],
-        });
-    }
-    return findings;
-};
-/**
- * Forbidden Patterns Rule
- * Detects forbidden patterns in code
- */
-const forbiddenPatternsRule = (input, policy) => {
-    if (policy.type !== 'forbidden-patterns')
-        return [];
-    const findings = [];
-    if (!policy.patterns)
-        return findings;
-    for (const pattern of policy.patterns) {
-        const regex = new RegExp(pattern.pattern, pattern.caseSensitive ? 'g' : 'gi');
-        const lines = input.content.split('\n');
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const matches = line.match(regex);
-            if (matches) {
-                findings.push({
-                    id: `forbidden-${policy.id}-${i}`,
-                    ruleId: policy.id,
-                    severity: pattern.severity,
-                    category: policy.category,
-                    message: pattern.message,
-                    filePath: input.file,
-                    line: i + 1,
-                    column: line.indexOf(matches[0]) + 1,
-                    suggestion: 'Remove or replace this pattern',
-                    relatedFindings: [],
-                });
-            }
-        }
-    }
-    return findings;
-};
-/**
- * Complexity Rule
- * Calculates code complexity
- */
-const complexityRule = (input, policy) => {
-    if (policy.type !== 'complexity')
-        return [];
-    const findings = [];
-    // Count decision points (if, switch, for, while, etc.)
-    const decisionPoints = [
-        /\bif\s*\(/g,
-        /\bswitch\s*\(/g,
-        /\bfor\s*\(/g,
-        /\bwhile\s*\(/g,
-        /\bcatch\s*\(/g,
-        /\?\s*[^:]+:/g, // ternary
-    ];
-    let cyclomaticComplexity = 1; // base complexity
-    for (const pattern of decisionPoints) {
-        const matches = input.content.match(pattern);
-        if (matches) {
-            cyclomaticComplexity += matches.length;
-        }
-    }
-    if (policy.maxCyclomaticComplexity && cyclomaticComplexity > policy.maxCyclomaticComplexity) {
-        findings.push({
-            id: `complexity-${input.file}`,
-            ruleId: policy.id,
-            severity: policy.severity,
-            category: policy.category,
-            message: `Cyclomatic complexity (${cyclomaticComplexity}) exceeds maximum (${policy.maxCyclomaticComplexity})`,
-            filePath: input.file,
-            line: 1,
-            column: 1,
-            suggestion: 'Refactor into smaller functions to reduce complexity',
-            relatedFindings: [],
-        });
-    }
-    return findings;
-};
-/**
- * Register all rules
- */
-export function registerDefaultRules() {
-    rulesRegistry.register({
-        id: 'file-size',
-        name: 'File Size Check',
-        description: 'Checks if files exceed maximum size limits',
-        category: 'maintainability',
-        execute: fileSizeRule,
-    });
-    rulesRegistry.register({
-        id: 'forbidden-patterns',
-        name: 'Forbidden Patterns',
-        description: 'Detects forbidden patterns in code',
-        category: 'security',
-        execute: forbiddenPatternsRule,
-    });
-    rulesRegistry.register({
-        id: 'complexity',
-        name: 'Code Complexity',
-        description: 'Analyzes code complexity metrics',
-        category: 'maintainability',
-        execute: complexityRule,
-    });
-}
-// Auto-register on module load
-registerDefaultRules();
-//# sourceMappingURL=index.js.map

package/dist/packages/domain/src/types/analysis.js

@@ -1,6 +0,0 @@
-/**
- * Analysis types
- * @see docs/architecture/OVERVIEW.md#data-flow
- */
-export {};
-//# sourceMappingURL=analysis.js.map

package/dist/packages/domain/src/types/errors.js

@@ -1,53 +0,0 @@
-/**
- * Base error class for Delta Platform
- * @see docs/architecture/OVERVIEW.md#error-handling
- */
-export class DeltaError extends Error {
-    code;
-    incidentId;
-    timestamp;
-    constructor(code, message, incidentId) {
-        super(message);
-        this.code = code;
-        this.incidentId = incidentId;
-        this.timestamp = new Date();
-        this.name = 'DeltaError';
-    }
-}
-/**
- * Configuration-related errors
- */
-export class ConfigError extends DeltaError {
-    constructor(message, incidentId) {
-        super('CONFIG_ERROR', message, incidentId);
-        this.name = 'ConfigError';
-    }
-}
-/**
- * Analysis-related errors
- */
-export class AnalysisError extends DeltaError {
-    constructor(message, incidentId) {
-        super('ANALYSIS_ERROR', message, incidentId);
-        this.name = 'AnalysisError';
-    }
-}
-/**
- * Sync-related errors
- */
-export class SyncError extends DeltaError {
-    constructor(message, incidentId) {
-        super('SYNC_ERROR', message, incidentId);
-        this.name = 'SyncError';
-    }
-}
-/**
- * File system-related errors
- */
-export class FileSystemError extends DeltaError {
-    constructor(message, incidentId) {
-        super('FS_ERROR', message, incidentId);
-        this.name = 'FileSystemError';
-    }
-}
-//# sourceMappingURL=errors.js.map

package/dist/packages/domain/src/types/fs.js

@@ -1,6 +0,0 @@
-/**
- * File system types
- * @see docs/architecture/OVERVIEW.md#file-system-abstraction
- */
-export {};
-//# sourceMappingURL=fs.js.map

package/dist/packages/domain/src/types/index.js

@@ -1,7 +0,0 @@
-/**
- * Core types index
- */
-export * from './errors.js';
-export * from './fs.js';
-export * from './analysis.js';
-//# sourceMappingURL=index.js.map

package/dist/plugins/GitStatusPlugin.js

@@ -1,93 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * GitStatusPlugin - MVP Plugin Example
- * Displays git repository status in the sidebar
- * Demonstrates Plugin System capabilities
- */
-import { execSync } from 'child_process';
-import { Box, Text } from 'ink';
-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 statusIcon = this.status === 'clean' ? '✓' : '⚡';
-        const statusColor = this.status === 'clean' ? 'green' : 'yellow';
-        return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, width: 28, marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "\uD83C\uDF3F Git Status" }), _jsxs(Text, { color: "white", children: ["Branch: ", this.branch] }), _jsxs(Text, { color: statusColor, children: [statusIcon, " ", this.status === 'clean' ? 'Clean' : 'Modified'] }), this.aheadBehind ? _jsx(Text, { color: "yellow", children: this.aheadBehind }) : null] }));
-    }
-}
-export default GitStatusPlugin;
-//# sourceMappingURL=GitStatusPlugin.js.map

package/dist/providers/ai-provider.js

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