@vee-stack/delta-cli 2.0.9 → 2.0.11

package/dist/core/completion.js

@@ -1,305 +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/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/core/engine.js

@@ -1,130 +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/core/exit-codes.js

@@ -1,79 +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