@vee-stack/delta-cli 2.0.8 → 2.0.9

package/dist/apps/cli/src/core/audit.js

@@ -1,184 +0,0 @@
-/**
- * Audit Logger for Delta CLI
- * Tracks all commands, results, and performance metrics
- * Enterprise-grade logging for compliance and debugging
- */
-import { promises as fs } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-const DEFAULT_CONFIG = {
-    enabled: true,
-    logLevel: 'standard',
-    retentionDays: 30,
-    maxEntries: 10000,
-    includeMetadata: true,
-};
-const AUDIT_DIR = join(homedir(), '.delta', 'audit');
-const AUDIT_FILE = join(AUDIT_DIR, 'commands.jsonl');
-const CONFIG_FILE = join(AUDIT_DIR, 'config.json');
-export class AuditLogger {
-    config;
-    initialized = false;
-    constructor() {
-        this.config = DEFAULT_CONFIG;
-    }
-    async initialize() {
-        if (this.initialized)
-            return;
-        try {
-            await fs.mkdir(AUDIT_DIR, { recursive: true });
-            // Load config if exists
-            try {
-                const configData = await fs.readFile(CONFIG_FILE, 'utf-8');
-                this.config = { ...DEFAULT_CONFIG, ...JSON.parse(configData) };
-            }
-            catch {
-                // Use defaults
-            }
-            this.initialized = true;
-        }
-        catch (error) {
-            console.error('Failed to initialize audit logger:', error);
-        }
-    }
-    async logCommand(command, args, options, response, startTime) {
-        if (!this.config.enabled)
-            return;
-        await this.initialize();
-        const entry = {
-            id: this.generateId(),
-            timestamp: new Date().toISOString(),
-            command,
-            args,
-            options: this.sanitizeOptions(options),
-            exitCode: response.exitCode || (response.success ? 0 : 1),
-            success: response.success,
-            duration: Date.now() - startTime,
-            provider: response.meta?.provider || 'unknown',
-            error: response.error,
-        };
-        if (this.config.includeMetadata) {
-            entry.metadata = {
-                nodeVersion: process.version,
-                platform: process.platform,
-                cwd: process.cwd(),
-                ci: process.env.CI === 'true',
-            };
-        }
-        // Write to log file
-        await this.appendEntry(entry);
-        // Send to remote if configured
-        if (this.config.remoteEndpoint) {
-            await this.sendRemote(entry).catch(() => { });
-        }
-    }
-    async getRecentEntries(limit = 50) {
-        await this.initialize();
-        try {
-            const data = await fs.readFile(AUDIT_FILE, 'utf-8');
-            const lines = data.trim().split('\n').filter(Boolean);
-            return lines
-                .slice(-limit)
-                .map(line => JSON.parse(line))
-                .reverse();
-        }
-        catch {
-            return [];
-        }
-    }
-    async getStats() {
-        const entries = await this.getRecentEntries(1000);
-        if (entries.length === 0) {
-            return {
-                totalCommands: 0,
-                successRate: 0,
-                avgDuration: 0,
-                mostUsed: [],
-                lastUsed: 'Never',
-            };
-        }
-        const commands = entries.map(e => e.command);
-        const successCount = entries.filter(e => e.success).length;
-        const totalDuration = entries.reduce((sum, e) => sum + e.duration, 0);
-        // Count command frequency
-        const frequency = {};
-        commands.forEach(cmd => {
-            frequency[cmd] = (frequency[cmd] || 0) + 1;
-        });
-        const mostUsed = Object.entries(frequency)
-            .sort((a, b) => b[1] - a[1])
-            .slice(0, 5)
-            .map(([cmd]) => cmd);
-        return {
-            totalCommands: entries.length,
-            successRate: Math.round((successCount / entries.length) * 100),
-            avgDuration: Math.round(totalDuration / entries.length),
-            mostUsed,
-            lastUsed: entries[0]?.timestamp || 'Never',
-        };
-    }
-    async appendEntry(entry) {
-        const line = JSON.stringify(entry) + '\n';
-        await fs.appendFile(AUDIT_FILE, line, 'utf-8');
-    }
-    async sendRemote(entry) {
-        if (!this.config.remoteEndpoint)
-            return;
-        try {
-            await fetch(this.config.remoteEndpoint, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify(entry),
-            });
-        }
-        catch {
-            // Silently fail - don't block CLI execution
-        }
-    }
-    sanitizeOptions(options) {
-        const sensitiveKeys = ['token', 'password', 'secret', 'key', 'auth'];
-        const sanitized = {};
-        for (const [key, value] of Object.entries(options)) {
-            if (sensitiveKeys.some(sk => key.toLowerCase().includes(sk))) {
-                sanitized[key] = '[REDACTED]';
-            }
-            else {
-                sanitized[key] = value;
-            }
-        }
-        return sanitized;
-    }
-    generateId() {
-        return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    }
-    // Cleanup old entries
-    async cleanup() {
-        if (!this.config.enabled)
-            return;
-        try {
-            const entries = await this.getRecentEntries(this.config.maxEntries);
-            const cutoff = new Date();
-            cutoff.setDate(cutoff.getDate() - this.config.retentionDays);
-            const validEntries = entries.filter(e => new Date(e.timestamp) > cutoff);
-            // Rewrite file with only valid entries
-            const data = validEntries.map(e => JSON.stringify(e)).join('\n') + '\n';
-            await fs.writeFile(AUDIT_FILE, data, 'utf-8');
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-    }
-}
-// Singleton instance
-let auditLogger = null;
-export function getAuditLogger() {
-    if (!auditLogger) {
-        auditLogger = new AuditLogger();
-    }
-    return auditLogger;
-}
-// Export for testing
-export function resetAuditLogger() {
-    auditLogger = null;
-}
-//# sourceMappingURL=audit.js.map

package/dist/apps/cli/src/core/completion.js

@@ -1,294 +0,0 @@
-/**
- * Tab Autocomplete System for Delta CLI
- * Provides shell completion for commands, flags, and options
- */
-// Completion items database
-export const completionDatabase = {
-    commands: [
-        { name: 'help', alias: ['/?', '/h'], desc: 'Show help' },
-        { name: 'analyze', alias: ['/a', '/analyze'], desc: 'Code analysis' },
-        { name: 'init', alias: ['/i', '/init'], desc: 'Initialize project' },
-        { name: 'status', alias: ['/st', '/status'], desc: 'Check status' },
-        { name: 'login', alias: ['/login'], desc: 'Authenticate' },
-        { name: 'logout', alias: ['/logout'], desc: 'Sign out' },
-        { name: 'whoami', alias: ['/me', '/whoami'], desc: 'User info' },
-        { name: 'config', alias: ['/config'], desc: 'Configuration' },
-        { name: 'dashboard', alias: ['/ui', '/dashboard'], desc: 'Interactive UI' },
-        { name: 'sync', alias: ['/sync'], desc: 'Cloud sync' },
-        { name: 'deploy', alias: ['/deploy'], desc: 'Deploy project' },
-        { name: 'plugins', alias: ['/plugins'], desc: 'Manage plugins' },
-    ],
-    globalFlags: [
-        { name: '--json', desc: 'Output as JSON' },
-        { name: '--provider', values: ['local', 'remote', 'ai'], desc: 'Execution provider' },
-        { name: '--theme', values: ['delta', 'cyber', 'sunset', 'neon', 'ocean', 'fire'], desc: 'Color theme' },
-        { name: '--verbose', desc: 'Verbose logging' },
-        { name: '--no-color', desc: 'Disable colors' },
-        { name: '--interactive', alias: '-i', desc: 'Interactive mode' },
-        { name: '--version', alias: '-v', desc: 'Show version' },
-        { name: '--help', alias: '-h', desc: 'Show help' },
-    ],
-    commandFlags: {
-        analyze: [
-            { name: '--format', values: ['json', 'html', 'markdown', 'sarif'], desc: 'Output format' },
-            { name: '--output', values: ['./delta-reports'], desc: 'Output directory' },
-            { name: '--include', desc: 'Include patterns' },
-            { name: '--exclude', desc: 'Exclude patterns' },
-            { name: '--max-size', desc: 'Max file size' },
-            { name: '--upload', desc: 'Upload to cloud' },
-            { name: '--share', desc: 'Generate shareable link' },
-            { name: '--project-name', desc: 'Project name' },
-            { name: '--ai-insights', desc: 'AI insights' },
-            { name: '--security-scan', desc: 'Security scan' },
-            { name: '--performance', desc: 'Performance analysis' },
-        ],
-        init: [
-            { name: '--template', values: ['default', 'nextjs', 'react', 'node', 'python'], desc: 'Project template' },
-            { name: '--force', alias: '-f', desc: 'Overwrite existing' },
-            { name: '--git', desc: 'Initialize git' },
-        ],
-        status: [
-            { name: '--diagnostics', desc: 'Full diagnostics' },
-            { name: '--fix', desc: 'Auto-fix issues' },
-        ],
-        login: [
-            { name: '--method', values: ['oauth', 'pat', 'github', 'google'], desc: 'Auth method' },
-            { name: '--token', desc: 'PAT token' },
-        ],
-        config: [
-            { name: '--get', desc: 'Get config value' },
-            { name: '--set', desc: 'Set config value' },
-            { name: '--list', alias: '-l', desc: 'List all config' },
-            { name: '--reset', desc: 'Reset to default' },
-        ],
-    },
-};
-// Generate shell completion script
-export function generateCompletionScript(shell) {
-    const cliName = 'delta';
-    switch (shell) {
-        case 'bash':
-            return generateBashCompletion(cliName);
-        case 'zsh':
-            return generateZshCompletion(cliName);
-        case 'fish':
-            return generateFishCompletion(cliName);
-        case 'powershell':
-            return generatePowershellCompletion(cliName);
-        default:
-            throw new Error(`Unsupported shell: ${shell}`);
-    }
-}
-function generateBashCompletion(cliName) {
-    const commands = completionDatabase.commands.map(c => c.name).join(' ');
-    const slashCommands = completionDatabase.commands.flatMap(c => c.alias).filter(a => a.startsWith('/')).join(' ');
-    return `#!/bin/bash
-# Delta CLI Bash Completion
-# Source this file: source <(delta completion bash)
-
-_${cliName}_completions() {
-  local cur prev opts
-  COMPREPLY=()
-  cur="\${COMP_WORDS[COMP_CWORD]}"
-  prev="\${COMP_WORDS[COMP_CWORD-1]}"
-  
-  # Commands list
-  local commands="${commands} ${slashCommands}"
-  local global_flags="--json --provider --theme --verbose --no-color --interactive --version --help -i -v -h"
-  
-  # Complete commands
-  if [[ \${COMP_CWORD} -eq 1 ]]; then
-    COMPREPLY=( $(compgen -W "\${commands} \${global_flags}" -- \${cur}) )
-    return 0
-  fi
-  
-  # Complete flags based on command
-  case "\${COMP_WORDS[1]}" in
-    analyze|/a|/analyze)
-      opts="--format --output --include --exclude --max-size --upload --share --project-name --ai-insights --security-scan --performance --json --provider"
-      ;;
-    init|/i|/init)
-      opts="--template --force --git --json --provider -f"
-      ;;
-    status|/st|/status)
-      opts="--diagnostics --fix --json"
-      ;;
-    login|/login)
-      opts="--method --token --json"
-      ;;
-    config|/config)
-      opts="--get --set --list --reset -l --json"
-      ;;
-    *)
-      opts="\${global_flags}"
-      ;;
-  esac
-  
-  # Complete flag values
-  case "\${prev}" in
-    --provider)
-      COMPREPLY=( $(compgen -W "local remote ai" -- \${cur}) )
-      return 0
-      ;;
-    --theme)
-      COMPREPLY=( $(compgen -W "delta cyber sunset neon ocean fire" -- \${cur}) )
-      return 0
-      ;;
-    --format)
-      COMPREPLY=( $(compgen -W "json html markdown sarif" -- \${cur}) )
-      return 0
-      ;;
-    --template)
-      COMPREPLY=( $(compgen -W "default nextjs react node python" -- \${cur}) )
-      return 0
-      ;;
-    --method)
-      COMPREPLY=( $(compgen -W "oauth pat github google" -- \${cur}) )
-      return 0
-      ;;
-  esac
-  
-  COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
-  return 0
-}
-
-complete -F _${cliName}_completions ${cliName}
-`;
-}
-function generateZshCompletion(cliName) {
-    return `#compdef ${cliName}
-# Delta CLI Zsh Completion
-
-_${cliName}() {
-  local curcontext="$curcontext" state line
-  typeset -A opt_args
-  
-  _arguments -C \\
-    '(-h --help)'{-h,--help}'[Show help]' \\
-    '(-v --version)'{-v,--version}'[Show version]' \\
-    '(-i --interactive)'{-i,--interactive}'[Interactive mode]' \\
-    '--json[Output as JSON]' \\
-    '--provider[Execution provider]:provider:(local remote ai)' \\
-    '--theme[Color theme]:theme:(delta cyber sunset neon ocean fire)' \\
-    '--verbose[Verbose logging]' \\
-    '--no-color[Disable colors]' \\
-    '1: :->command' \\
-    '*:: :->args'
-  
-  case "$state" in
-    command)
-      _values 'commands' \\
-        'help[Show help]' \\
-        'analyze[Code analysis]' \\
-        'init[Initialize project]' \\
-        'status[Check status]' \\
-        'login[Authenticate]' \\
-        'logout[Sign out]' \\
-        'whoami[User info]' \\
-        'config[Configuration]' \\
-        'dashboard[Interactive UI]' \\
-        'sync[Cloud sync]' \\
-        'deploy[Deploy project]' \\
-        'plugins[Manage plugins]'
-      ;;
-    args)
-      case "$line[1]" in
-        analyze)
-          _arguments \\
-            '--format[Output format]:format:(json html markdown sarif)' \\
-            '--output[Output directory]' \\
-            '--include[Include patterns]' \\
-            '--exclude[Exclude patterns]' \\
-            '--upload[Upload to cloud]' \\
-            '--share[Generate shareable link]' \\
-            '--project-name[Project name]'
-          ;;
-        init)
-          _arguments \\
-            '--template[Project template]:template:(default nextjs react node python)' \\
-            '(-f --force)'{-f,--force}'[Overwrite existing]' \\
-            '--git[Initialize git]'
-          ;;
-        status)
-          _arguments \\
-            '--diagnostics[Full diagnostics]' \\
-            '--fix[Auto-fix issues]'
-          ;;
-      esac
-      ;;
-  esac
-}
-
-_${cliName} "$@"
-`;
-}
-function generateFishCompletion(cliName) {
-    return `# Delta CLI Fish Completion
-
-# Commands
-complete -c ${cliName} -f
-complete -c ${cliName} -n '__fish_use_subcommand' -a 'help' -d 'Show help'
-complete -c ${cliName} -n '__fish_use_subcommand' -a 'analyze' -d 'Code analysis'
-complete -c ${cliName} -n '__fish_use_subcommand' -a 'init' -d 'Initialize project'
-complete -c ${cliName} -n '__fish_use_subcommand' -a 'status' -d 'Check status'
-complete -c ${cliName} -n '__fish_use_subcommand' -a 'login' -d 'Authenticate'
-complete -c ${cliName} -n '__fish_use_subcommand' -a 'logout' -d 'Sign out'
-
-# Global flags
-complete -c ${cliName} -l json -d 'Output as JSON'
-complete -c ${cliName} -l provider -d 'Execution provider' -xa 'local remote ai'
-complete -c ${cliName} -l theme -d 'Color theme' -xa 'delta cyber sunset neon ocean fire'
-complete -c ${cliName} -l verbose -d 'Verbose logging'
-complete -c ${cliName} -l no-color -d 'Disable colors'
-complete -c ${cliName} -s i -l interactive -d 'Interactive mode'
-complete -c ${cliName} -s v -l version -d 'Show version'
-complete -c ${cliName} -s h -l help -d 'Show help'
-`;
-}
-function generatePowershellCompletion(cliName) {
-    return `# Delta CLI PowerShell Completion
-# Add to $PROFILE: . delta completion powershell | Out-String | Invoke-Expression
-
-Register-ArgumentCompleter -Native -CommandName ${cliName} -ScriptBlock {
-  param($wordToComplete, $commandAst, $cursorPosition)
-  
-  $commands = @('help', 'analyze', 'init', 'status', 'login', 'logout', 'whoami', 'config', 'dashboard', 'sync', 'deploy', 'plugins')
-  $slashCommands = @('/help', '/h', '/analyze', '/a', '/init', '/i', '/status', '/st', '/login', '/logout', '/me', '/whoami', '/config', '/ui', '/sync', '/deploy', '/plugins')
-  
-  $command = $commandAst.CommandElements[1].Value
-  
-  if ($commandAst.CommandElements.Count -eq 1 -or 
-      ($commandAst.CommandElements.Count -eq 2 -and $wordToComplete -ne '')) {
-    $commands + $slashCommands | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
-      [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
-    }
-    return
-  }
-  
-  switch ($command) {
-    { $_ -in 'analyze', '/a', '/analyze' } {
-      $flags = @('--format', '--output', '--include', '--exclude', '--upload', '--share', '--json', '--provider')
-      $flags | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
-        [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
-      }
-    }
-    { $_ -in 'init', '/i', '/init' } {
-      $flags = @('--template', '--force', '--git', '--json')
-      $flags | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
-        [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
-      }
-    }
-  }
-}
-`;
-}
-// Install completion for current shell
-export async function installCompletion(shell) {
-    const detectedShell = shell || process.env.SHELL?.split('/').pop() || 'bash';
-    console.log(`Installing completion for ${detectedShell}...\n`);
-    const script = generateCompletionScript(detectedShell);
-    console.log('Add this to your shell config:\n');
-    console.log(script);
-    console.log('\nOr run: eval "$(delta completion ' + detectedShell + ')"');
-}
-//# sourceMappingURL=completion.js.map

package/dist/apps/cli/src/core/contracts.js

@@ -1,6 +0,0 @@
-/**
- * Core Contracts - Interface definitions for Delta CLI
- * AI-Ready Architecture: Separate CLI from Business Logic
- */
-export {};
-//# sourceMappingURL=contracts.js.map

package/dist/apps/cli/src/core/engine.js

@@ -1,124 +0,0 @@
-/**
- * Delta Engine - Core Execution Engine
- * Mediator between CLI and Execution Providers
- */
-import { ExitCode, getExitCode } from './exit-codes.js';
-export class DeltaEngine {
-    providers = new Map();
-    config;
-    policy;
-    listeners = [];
-    version = '2.0.0';
-    constructor(config, policy) {
-        this.config = config;
-        this.policy = policy;
-    }
-    // Register an execution provider
-    registerProvider(provider) {
-        this.providers.set(provider.name, provider);
-    }
-    // Get registered provider
-    getProvider(name) {
-        return this.providers.get(name);
-    }
-    // Execute a task through the engine
-    async execute(request) {
-        const startTime = Date.now();
-        // Emit start event
-        this.emit({ type: 'task:start', request });
-        try {
-            // Validate request with policy (includes capability check)
-            const validation = this.policy.validate(request);
-            if (!validation.valid) {
-                const exitCode = validation.exitCode || ExitCode.VALIDATION_ERROR;
-                throw Object.assign(new Error(validation.reason || 'Task validation failed'), { code: exitCode === ExitCode.POLICY_BLOCKED ? 'POLICY_BLOCKED' : 'VALIDATION_ERROR', exitCode });
-            }
-            // Transform request if needed (includes non-TTY detection)
-            const transformedRequest = this.policy.transform?.(request) || request;
-            // Select appropriate provider using policy
-            const provider = this.policy.selectProvider(transformedRequest, this.providers);
-            if (!provider) {
-                throw Object.assign(new Error(`No provider available for task type '${transformedRequest.type}'`), { code: 'NO_PROVIDER', exitCode: ExitCode.POLICY_BLOCKED });
-            }
-            // Check provider availability
-            const available = await provider.isAvailable();
-            if (!available) {
-                throw Object.assign(new Error(`Provider '${provider.name}' is not available`), { code: 'PROVIDER_UNAVAILABLE', exitCode: ExitCode.NETWORK_ERROR });
-            }
-            // Execute task
-            this.emit({ type: 'task:progress', request: transformedRequest, progress: 0.5 });
-            const response = await provider.execute(transformedRequest);
-            // Enrich response with engine metadata
-            const enrichedResponse = {
-                ...response,
-                meta: {
-                    ...response.meta,
-                    command: request.command,
-                    duration: Date.now() - startTime,
-                    timestamp: new Date().toISOString(),
-                    version: this.version,
-                    coldStart: Date.now() - startTime - response.meta.duration,
-                    provider: provider.name,
-                },
-            };
-            // Emit completion
-            this.emit({
-                type: 'task:complete',
-                request: transformedRequest,
-                response: enrichedResponse
-            });
-            return enrichedResponse;
-        }
-        catch (error) {
-            // Emit error
-            this.emit({
-                type: 'task:error',
-                request,
-                error: error instanceof Error ? error : new Error(String(error))
-            });
-            return {
-                success: false,
-                exitCode: getExitCode(error),
-                meta: {
-                    command: request.command,
-                    duration: Date.now() - startTime,
-                    timestamp: new Date().toISOString(),
-                    version: this.version,
-                    provider: 'engine',
-                },
-                error: {
-                    code: error instanceof Error && 'code' in error
-                        ? error.code
-                        : 'EXECUTION_ERROR',
-                    message: error instanceof Error ? error.message : String(error),
-                },
-            };
-        }
-    }
-    // Subscribe to engine events
-    on(_event, listener) {
-        this.listeners.push(listener);
-    }
-    // Emit event to all listeners
-    emit(event) {
-        this.listeners.forEach(listener => listener(event));
-    }
-    // Get engine status
-    getStatus() {
-        return {
-            version: this.version,
-            providers: Array.from(this.providers.keys()),
-            defaultProvider: this.config.defaultProvider,
-        };
-    }
-}
-// Singleton instance
-let engineInstance = null;
-export function createEngine(config, policy) {
-    engineInstance = new DeltaEngine(config, policy);
-    return engineInstance;
-}
-export function getEngine() {
-    return engineInstance;
-}
-//# sourceMappingURL=engine.js.map

package/dist/apps/cli/src/core/exit-codes.js

@@ -1,71 +0,0 @@
-/**
- * Exit Code Contract - Enterprise-grade error classification
- * Critical for CI/CD integration and automation
- */
-export var ExitCode;
-(function (ExitCode) {
-    ExitCode[ExitCode["SUCCESS"] = 0] = "SUCCESS";
-    ExitCode[ExitCode["VALIDATION_ERROR"] = 1] = "VALIDATION_ERROR";
-    ExitCode[ExitCode["NETWORK_ERROR"] = 2] = "NETWORK_ERROR";
-    ExitCode[ExitCode["AUTH_ERROR"] = 3] = "AUTH_ERROR";
-    ExitCode[ExitCode["POLICY_BLOCKED"] = 4] = "POLICY_BLOCKED";
-    ExitCode[ExitCode["EXECUTION_ERROR"] = 5] = "EXECUTION_ERROR";
-    ExitCode[ExitCode["UNKNOWN_ERROR"] = 6] = "UNKNOWN_ERROR";
-})(ExitCode || (ExitCode = {}));
-// Error to Exit Code mapping
-export function getExitCode(error) {
-    const errorStr = typeof error === 'string'
-        ? error
-        : error instanceof Error
-            ? error.message
-            : error.message || String(error);
-    const errorCode = typeof error === 'object' && 'code' in error ? error.code : undefined;
-    // Check error codes first
-    if (errorCode) {
-        switch (errorCode) {
-            case 'VALIDATION_ERROR':
-            case 'INVALID_INPUT':
-            case 'MISSING_ARGUMENT':
-                return ExitCode.VALIDATION_ERROR;
-            case 'AUTH_ERROR':
-            case 'UNAUTHORIZED':
-            case 'TOKEN_EXPIRED':
-                return ExitCode.AUTH_ERROR;
-            case 'NETWORK_ERROR':
-            case 'CONNECTION_FAILED':
-            case 'TIMEOUT':
-                return ExitCode.NETWORK_ERROR;
-            case 'POLICY_BLOCKED':
-            case 'QUOTA_EXCEEDED':
-            case 'PERMISSION_DENIED':
-                return ExitCode.POLICY_BLOCKED;
-            case 'EXECUTION_ERROR':
-                return ExitCode.EXECUTION_ERROR;
-        }
-    }
-    // Check error messages
-    if (errorStr.includes('validation') || errorStr.includes('invalid') || errorStr.includes('required')) {
-        return ExitCode.VALIDATION_ERROR;
-    }
-    if (errorStr.includes('auth') || errorStr.includes('token') || errorStr.includes('unauthorized')) {
-        return ExitCode.AUTH_ERROR;
-    }
-    if (errorStr.includes('network') || errorStr.includes('connection') || errorStr.includes('timeout')) {
-        return ExitCode.NETWORK_ERROR;
-    }
-    if (errorStr.includes('policy') || errorStr.includes('quota') || errorStr.includes('permission')) {
-        return ExitCode.POLICY_BLOCKED;
-    }
-    return ExitCode.EXECUTION_ERROR;
-}
-// Human-readable exit code descriptions
-export const ExitCodeDescription = {
-    [ExitCode.SUCCESS]: 'Success',
-    [ExitCode.VALIDATION_ERROR]: 'Validation error - check your input',
-    [ExitCode.NETWORK_ERROR]: 'Network error - check your connection',
-    [ExitCode.AUTH_ERROR]: 'Authentication error - please login',
-    [ExitCode.POLICY_BLOCKED]: 'Policy blocked - insufficient permissions or quota',
-    [ExitCode.EXECUTION_ERROR]: 'Execution error - task failed during execution',
-    [ExitCode.UNKNOWN_ERROR]: 'Unknown error - please report this issue',
-};
-//# sourceMappingURL=exit-codes.js.map