@vee-stack/delta-cli 2.0.1

package/dist/apps/cli/src/index.d.ts

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+export declare const gradients: {
+    delta: {
+        (text: string): string;
+        multiline(text: string): string;
+    };
+    cyber: {
+        (text: string): string;
+        multiline(text: string): string;
+    };
+    sunset: {
+        (text: string): string;
+        multiline(text: string): string;
+    };
+    neon: {
+        (text: string): string;
+        multiline(text: string): string;
+    };
+    ocean: {
+        (text: string): string;
+        multiline(text: string): string;
+    };
+    fire: {
+        (text: string): string;
+        multiline(text: string): string;
+    };
+};
+export declare function printLogo(variant?: keyof typeof gradients): void;
+export declare function printMinimalLogo(): void;
+export declare function printWelcome(): void;
+export declare function printTips(): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/apps/cli/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/index.tsx"],"names":[],"mappings":";AAqCA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;CAOrB,CAAC;AAGF,wBAAgB,SAAS,CAAC,OAAO,GAAE,MAAM,OAAO,SAAmB,GAAG,IAAI,CAOzE;AAGD,wBAAgB,gBAAgB,IAAI,IAAI,CAMvC;AAGD,wBAAgB,YAAY,IAAI,IAAI,CAoBnC;AAGD,wBAAgB,SAAS,IAAI,IAAI,CAiBhC"}

package/dist/apps/cli/src/index.js

@@ -0,0 +1,636 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import gradient from 'gradient-string';
+import figlet from 'figlet';
+import updateNotifier from 'update-notifier';
+import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { runInteractiveMode } from './interactive/index.js';
+// Core Engine Imports
+import { createEngine } from './core/engine.js';
+import { DefaultExecutionPolicy } from './core/policy.js';
+import { LocalProvider } from './providers/local-provider.js';
+import { RemoteProvider } from './providers/remote-provider.js';
+import { AIProviderPlaceholder } from './providers/ai-provider.js';
+import { installCompletion, generateCompletionScript } from './core/completion.js';
+import { runInitWizard, executeWizardActions } from './core/wizard.js';
+import { getAuditLogger } from './core/audit.js';
+import { getProfileManager } from './core/profiles.js';
+import { getHookManager, hookTemplates } from './core/hooks.js';
+import { loadConfig } from './commands/auth.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Read package.json for version info
+const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf8'));
+// Check for updates
+const notifier = updateNotifier({
+    pkg,
+    updateCheckInterval: 1000 * 60 * 60 // 1 hour
+});
+// Define gradient themes
+export const gradients = {
+    delta: gradient(['#00d4ff', '#7b2cbf', '#ff006e']),
+    cyber: gradient(['#00f5ff', '#0080ff', '#8000ff']),
+    sunset: gradient(['#ff4e50', '#fca311', '#e85d04']),
+    neon: gradient(['#39ff14', '#00ffff', '#ff00ff']),
+    ocean: gradient(['#0066ff', '#00ccff', '#66ffff']),
+    fire: gradient(['#ff4e00', '#ff9500', '#ffcc00']),
+};
+// Print animated logo
+export function printLogo(variant = 'delta') {
+    const text = figlet.textSync('DELTA', {
+        font: 'Big Money-nw',
+        horizontalLayout: 'default',
+        verticalLayout: 'default',
+    });
+    console.log('\n' + gradients[variant](text) + '\n');
+}
+// Print minimal logo
+export function printMinimalLogo() {
+    const text = figlet.textSync('Δ', {
+        font: 'ANSI Shadow',
+        horizontalLayout: 'default',
+    });
+    console.log(gradients.delta(text));
+}
+// Print welcome screen
+export function printWelcome() {
+    console.clear();
+    printLogo();
+    console.log(chalk.dim('  ═══════════════════════════════════════════════════════════════'));
+    console.log();
+    console.log(chalk.white.bold('  🚀 Delta CLI v2.0') + chalk.gray(' — Next-gen code analysis & documentation'));
+    console.log();
+    console.log(chalk.gray('  Local-first architecture with ') + chalk.cyan('cloud power') + chalk.gray(' & ') + chalk.magenta('AI intelligence'));
+    console.log();
+    console.log(chalk.dim('  ═══════════════════════════════════════════════════════════════'));
+    console.log();
+    // Update notification
+    if (notifier.update) {
+        console.log(chalk.yellow.bold('  ⚡ Update Available!'));
+        console.log(chalk.gray(`     ${notifier.update.current} → ${notifier.update.latest}`));
+        console.log(chalk.cyan(`     Run: npm install -g ${pkg.name}`));
+        console.log();
+    }
+}
+// Print tips
+export function printTips() {
+    const tips = [
+        { cmd: 'delta /help', desc: 'Quick help with slash commands' },
+        { cmd: 'delta /analyze', desc: 'Run analysis with / command' },
+        { cmd: 'delta /status', desc: 'Check project status' },
+        { cmd: 'delta --interactive', desc: 'Open interactive dashboard' },
+    ];
+    console.log(chalk.bold.cyan('  Quick Start (Slash Commands Available):'));
+    console.log();
+    tips.forEach(({ cmd, desc }) => {
+        console.log(chalk.gray('    • ') + chalk.cyan(cmd) + chalk.gray(` — ${desc}`));
+    });
+    console.log();
+    console.log(chalk.dim('  Try ') + chalk.cyan('/help') + chalk.dim(', ') + chalk.cyan('/analyze') + chalk.dim(', ') + chalk.cyan('/status') + chalk.dim(' for quick access'));
+    console.log(chalk.dim('  Press ') + chalk.bold('Ctrl+T') + chalk.dim(' for variants • ') + chalk.bold('Tab') + chalk.dim(' for agents • ') + chalk.bold('Ctrl+P') + chalk.dim(' for commands'));
+    console.log();
+}
+// Initialize Core Engine
+let engine = null;
+async function initializeEngine() {
+    if (engine)
+        return engine;
+    const auth = await loadConfig();
+    const config = {
+        defaultProvider: 'local',
+        providers: {
+            local: {
+                enabled: true,
+                maxFileSize: 10 * 1024 * 1024, // 10MB
+                excludePatterns: ['node_modules', 'dist', '.git', 'coverage'],
+            },
+            remote: {
+                enabled: !!auth.pat,
+                apiUrl: auth.apiUrl || 'https://api.delta.dev',
+                timeout: 30000,
+                retryAttempts: 3,
+            },
+            ai: {
+                enabled: false, // Reserved for future
+                provider: 'openai',
+            },
+        },
+        features: {
+            cache: true,
+            offlineMode: !auth.pat,
+            autoUpdate: true,
+        },
+    };
+    const policy = new DefaultExecutionPolicy(config);
+    engine = createEngine(config, policy);
+    // Register providers
+    engine.registerProvider(new LocalProvider(config.providers.local));
+    if (config.providers.remote.enabled) {
+        engine.registerProvider(new RemoteProvider(config.providers.remote));
+    }
+    engine.registerProvider(new AIProviderPlaceholder(config.providers.ai));
+    return engine;
+}
+// JSON Output Helper
+function outputJSON(response) {
+    console.log(JSON.stringify(response, null, 2));
+}
+// Non-TTY Detection
+function isNonTTY() {
+    return !process.stdout.isTTY || process.env.CI === 'true' || process.env.NO_COLOR === 'true';
+}
+// CLI Program Setup
+const program = new Command();
+program
+    .name('delta')
+    .description('Delta Platform - Next-gen code analysis and documentation')
+    .version(pkg.version, '-v, --version', 'Display version number')
+    .usage('<command> [options]')
+    .helpOption('-h, --help', 'Display help for command')
+    .addHelpCommand('help [command]', 'Display help for command');
+// Global options
+program
+    .option('-i, --interactive', 'Run in interactive mode', false)
+    .option('--no-color', 'Disable colored output', false)
+    .option('--theme <name>', 'Set color theme (delta, cyber, sunset, neon, ocean, fire)', 'delta')
+    .option('--verbose', 'Enable verbose logging', false);
+// Auth commands
+program
+    .command('login')
+    .description('🔐 Authenticate with Delta cloud (OAuth2 + secure keychain storage)')
+    .option('--method <type>', 'Auth method: oauth, pat, github, google', 'oauth')
+    .option('--token <token>', 'Personal Access Token (for CI/CD)')
+    .action(async (options) => {
+    printWelcome();
+    const { loginCommand } = await import('./commands/auth.js');
+    await loginCommand(options);
+});
+program
+    .command('logout')
+    .description('🔓 Remove stored authentication and clear credentials')
+    .action(async () => {
+    const { logoutCommand } = await import('./commands/logout.js');
+    await logoutCommand();
+});
+program
+    .command('whoami')
+    .alias('me')
+    .description('👤 Show current user, plan, quota, and session info')
+    .option('--format <type>', 'Output format: table, json, compact', 'table')
+    .action(async (options) => {
+    const { whoamiCommand } = await import('./commands/whoami.js');
+    await whoamiCommand(options);
+});
+// Main commands
+program
+    .command('manager')
+    .alias('mgr')
+    .description('🎛️  Launch Unified Manager TUI - Run CLI + Web from single terminal')
+    .action(async () => {
+    printWelcome();
+    console.log(chalk.cyan('\n🚀 Starting Unified Manager...\n'));
+    console.log(chalk.gray('Press ? for help, q to quit\n'));
+    await runInteractiveMode({ mode: 'manager' });
+});
+program
+    .command('analyze [path]')
+    .alias('a')
+    .description('🔍 Run comprehensive code analysis with AI insights')
+    .option('-f, --format <type>', 'Output format: json, html, markdown, sarif', 'json')
+    .option('-o, --output <dir>', 'Output directory', './delta-reports')
+    .option('-i, --include <patterns...>', 'Include file patterns')
+    .option('-e, --exclude <patterns...>', 'Exclude file patterns')
+    .option('--max-size <bytes>', 'Max file size in bytes', '10485760')
+    .option('--upload', 'Upload report to Delta cloud', false)
+    .option('--share', 'Generate shareable link after upload', false)
+    .option('--project-name <name>', 'Project name for the report')
+    .option('--ai-insights', 'Enable AI-powered code insights', true)
+    .option('--security-scan', 'Enable security vulnerability scan', true)
+    .option('--performance', 'Enable performance analysis', true)
+    .option('--json', 'Output results as JSON', false)
+    .option('--provider <name>', 'Execution provider: local, remote, ai', 'local')
+    .action(async (path, options) => {
+    const engine = await initializeEngine();
+    const targetPath = path || '.';
+    const response = await engine.execute({
+        type: 'analyze',
+        command: 'analyze',
+        payload: {
+            targetPath,
+            options: {
+                format: options.format,
+                output: options.output,
+                maxSize: parseInt(options.maxSize, 10),
+                projectName: options.projectName,
+            },
+        },
+        options: {
+            json: options.json || isNonTTY(),
+            provider: options.provider,
+        },
+    });
+    if (options.json || isNonTTY()) {
+        outputJSON(response);
+    }
+    else {
+        // Human-readable output
+        if (response.success) {
+            console.log('\n✅ Analysis complete');
+            console.log(`   Files analyzed: ${response.data?.filesAnalyzed}`);
+            console.log(`   Findings: ${response.data?.findings}`);
+            console.log(`   Report: ${response.data?.reportFile}`);
+        }
+        else {
+            console.error('\n❌ Analysis failed:', response.error?.message);
+            process.exit(1);
+        }
+    }
+});
+program
+    .command('init [path]')
+    .description('🚀 Initialize a new Delta project with wizard')
+    .option('-t, --template <name>', 'Project template: default, nextjs, react, node, python', 'default')
+    .option('-f, --force', 'Overwrite existing config', false)
+    .option('--git', 'Initialize git repository', false)
+    .option('--json', 'Output results as JSON', false)
+    .option('--provider <name>', 'Execution provider: local, remote', 'local')
+    .option('-w, --wizard', 'Run interactive wizard', false)
+    .action(async (path, options) => {
+    // Run wizard if requested or no path provided
+    if (options.wizard || !path) {
+        const wizardResult = await runInitWizard();
+        await executeWizardActions(wizardResult);
+        // Then run engine init with wizard results
+        const engine = await initializeEngine();
+        const response = await engine.execute({
+            type: 'init',
+            command: 'init',
+            payload: {
+                projectPath: wizardResult.projectPath,
+                template: wizardResult.template,
+                force: options.force,
+                git: wizardResult.initializeGit,
+            },
+            options: {
+                json: options.json || isNonTTY(),
+                provider: options.provider,
+            },
+        });
+        if (options.json || isNonTTY()) {
+            outputJSON(response);
+        }
+        return;
+    }
+    // Standard init flow
+    const engine = await initializeEngine();
+    const projectPath = path || '.';
+    const response = await engine.execute({
+        type: 'init',
+        command: 'init',
+        payload: {
+            projectPath,
+            template: options.template,
+            force: options.force,
+            git: options.git,
+        },
+        options: {
+            json: options.json || isNonTTY(),
+            provider: options.provider,
+        },
+    });
+    if (options.json || isNonTTY()) {
+        outputJSON(response);
+    }
+    else {
+        printWelcome();
+        if (response.success) {
+            console.log('\n📁 Project initialized');
+            console.log(`   Path: ${response.data?.projectPath}`);
+            console.log(`   Config: ${response.data?.configPath}`);
+            console.log(`   Template: ${response.data?.template}`);
+        }
+        else {
+            console.error('\n❌ Init failed:', response.error?.message);
+            process.exit(1);
+        }
+    }
+});
+program
+    .command('config')
+    .description('⚙️  Manage CLI configuration with schema validation')
+    .option('-g, --get <key>', 'Get config value')
+    .option('-s, --set <key=value>', 'Set config value')
+    .option('-l, --list', 'List all config')
+    .option('--reset', 'Reset to default configuration')
+    .action(async (options) => {
+    const { configCommand } = await import('./commands/config.js');
+    await configCommand(options);
+});
+program
+    .command('status [path]')
+    .alias('st')
+    .description('📈 Check project health, connection status, and diagnostics')
+    .option('--diagnostics', 'Run full diagnostics', false)
+    .option('--fix', 'Auto-fix issues where possible', false)
+    .option('--json', 'Output results as JSON', false)
+    .action(async (path, options) => {
+    const engine = await initializeEngine();
+    const projectPath = path || '.';
+    const response = await engine.execute({
+        type: 'status',
+        command: 'status',
+        payload: {
+            projectPath,
+            diagnostics: options.diagnostics,
+            fix: options.fix,
+        },
+        options: {
+            json: options.json || isNonTTY(),
+        },
+    });
+    if (options.json || isNonTTY()) {
+        outputJSON(response);
+    }
+    else {
+        if (response.success) {
+            const data = response.data;
+            console.log('\n📊 Project Status');
+            console.log(`   Path: ${data?.project?.path || 'N/A'}`);
+            console.log(`   Config: ${data?.project?.hasConfig ? '✅' : '❌'}`);
+            console.log(`   Auth: ${data?.auth?.authenticated ? '✅' : '❌'}`);
+        }
+        else {
+            console.error('\n❌ Status check failed:', response.error?.message);
+        }
+    }
+});
+program
+    .command('completion [shell]')
+    .description('🔧 Generate shell completion script (bash, zsh, fish, powershell)')
+    .option('--install', 'Install completion for current shell', false)
+    .action(async (shell, options) => {
+    const targetShell = shell || 'bash';
+    if (options.install) {
+        await installCompletion(targetShell);
+    }
+    else {
+        console.log(generateCompletionScript(targetShell));
+    }
+});
+// New advanced commands
+program
+    .command('sync')
+    .description('☁️  Sync local analysis with Delta cloud in real-time')
+    .option('--watch', 'Watch for changes and auto-sync', false)
+    .option('--force', 'Force sync and overwrite remote', false)
+    .action(async (options) => {
+    const { syncCommand } = await import('./commands/sync.js');
+    await syncCommand(options);
+});
+program
+    .command('deploy')
+    .description('🚀 Deploy documentation site to Delta hosting')
+    .option('--build', 'Build before deploy', true)
+    .option('--domain <name>', 'Custom domain')
+    .action(async (options) => {
+    const { deployCommand } = await import('./commands/deploy.js');
+    await deployCommand(options);
+});
+program
+    .command('plugins')
+    .description('🔌 Manage Delta CLI plugins and extensions')
+    .option('--list', 'List installed plugins')
+    .option('--install <name>', 'Install a plugin')
+    .option('--uninstall <name>', 'Uninstall a plugin')
+    .option('--search <query>', 'Search for plugins')
+    .action(async (options) => {
+    const { pluginsCommand } = await import('./commands/plugins.js');
+    await pluginsCommand(options);
+});
+program
+    .command('profile [action]')
+    .description('🎭 Manage environment profiles (dev/staging/prod)')
+    .option('--list', 'List all profiles', false)
+    .option('--use <name>', 'Switch to profile', '')
+    .option('--create <name>', 'Create new profile', '')
+    .option('--delete <name>', 'Delete profile', '')
+    .option('--provider <name>', 'Provider for new profile', 'local')
+    .option('--api-url <url>', 'API URL for remote profile', '')
+    .option('--json', 'Output as JSON', false)
+    .action(async (action, options) => {
+    const profiles = getProfileManager();
+    await profiles.load();
+    // Apply profile to environment
+    profiles.applyToEnvironment();
+    if (options.list || action === 'list') {
+        const list = profiles.listProfiles();
+        if (options.json) {
+            console.log(JSON.stringify(list, null, 2));
+        }
+        else {
+            console.log(chalk.bold.cyan('\n🎭 Profiles\n'));
+            list.forEach(p => {
+                const active = p.active ? chalk.green('●') : chalk.gray('○');
+                const name = p.active ? chalk.bold(p.name) : p.name;
+                console.log(`  ${active} ${name} ${chalk.gray(`(${p.provider})`)}`);
+            });
+            console.log(chalk.gray('\nActive profile affects provider selection and API endpoints'));
+        }
+        return;
+    }
+    if (options.use) {
+        await profiles.setActiveProfile(options.use);
+        console.log(chalk.green(`✅ Switched to profile: ${options.use}`));
+        return;
+    }
+    if (options.create) {
+        await profiles.createProfile(options.create, {
+            provider: options.provider,
+            apiUrl: options.apiUrl || undefined,
+        });
+        console.log(chalk.green(`✅ Created profile: ${options.create}`));
+        return;
+    }
+    if (options.delete) {
+        await profiles.deleteProfile(options.delete);
+        console.log(chalk.green(`✅ Deleted profile: ${options.delete}`));
+        return;
+    }
+    // Show current profile
+    const current = profiles.getActiveProfile();
+    if (options.json) {
+        console.log(JSON.stringify(current, null, 2));
+    }
+    else {
+        console.log(chalk.bold.cyan('\n🎭 Active Profile\n'));
+        console.log(`  Name: ${chalk.bold(current.name)}`);
+        console.log(`  Provider: ${current.provider}`);
+        console.log(`  Timeout: ${current.timeout}ms`);
+        console.log(`  Retries: ${current.retries}`);
+        if (current.apiUrl)
+            console.log(`  API URL: ${current.apiUrl}`);
+        console.log(`  Features: ${Object.entries(current.features)
+            .filter(([, v]) => v)
+            .map(([k]) => k)
+            .join(', ') || 'none'}`);
+    }
+});
+program
+    .command('audit')
+    .description('📋 View audit log of recent commands')
+    .option('--recent <n>', 'Show last N entries', '50')
+    .option('--stats', 'Show usage statistics', false)
+    .option('--json', 'Output as JSON', false)
+    .action(async (options) => {
+    const audit = getAuditLogger();
+    if (options.stats) {
+        const stats = await audit.getStats();
+        if (options.json) {
+            console.log(JSON.stringify(stats, null, 2));
+        }
+        else {
+            console.log(chalk.bold.cyan('\n📊 Audit Statistics\n'));
+            console.log(`  Total Commands: ${stats.totalCommands}`);
+            console.log(`  Success Rate: ${stats.successRate}%`);
+            console.log(`  Avg Duration: ${stats.avgDuration}ms`);
+            console.log(`  Most Used: ${stats.mostUsed.join(', ') || 'N/A'}`);
+            console.log(`  Last Used: ${stats.lastUsed}`);
+        }
+        return;
+    }
+    const entries = await audit.getRecentEntries(parseInt(options.recent, 10));
+    if (options.json) {
+        console.log(JSON.stringify(entries, null, 2));
+    }
+    else {
+        console.log(chalk.bold.cyan(`\n📋 Recent Commands (last ${entries.length})\n`));
+        entries.forEach(entry => {
+            const status = entry.success ? chalk.green('✓') : chalk.red('✗');
+            const cmd = chalk.cyan(entry.command);
+            const time = chalk.gray(new Date(entry.timestamp).toLocaleTimeString());
+            const duration = chalk.gray(`${entry.duration}ms`);
+            console.log(`  ${status} ${cmd} ${time} ${duration}`);
+        });
+    }
+});
+program
+    .command('hooks')
+    .description('🔔 Manage webhooks and notifications (Slack, Teams)')
+    .option('--list', 'List all hooks', false)
+    .option('--add-slack <url>', 'Add Slack webhook')
+    .option('--add-teams <url>', 'Add Teams webhook')
+    .option('--remove <id>', 'Remove hook by ID')
+    .option('--toggle <id>', 'Toggle hook on/off')
+    .option('--json', 'Output as JSON', false)
+    .action(async (options) => {
+    const hooks = getHookManager();
+    await hooks.load();
+    if (options.list) {
+        const list = await hooks.listHooks();
+        if (options.json) {
+            console.log(JSON.stringify(list, null, 2));
+        }
+        else {
+            console.log(chalk.bold.cyan('\n🔔 Hooks\n'));
+            if (list.length === 0) {
+                console.log(chalk.gray('  No hooks configured'));
+            }
+            else {
+                list.forEach(h => {
+                    const status = h.enabled ? chalk.green('●') : chalk.red('●');
+                    console.log(`  ${status} ${h.name} ${chalk.gray(`(${h.type})`)}`);
+                    console.log(`     ${chalk.gray(h.url)}`);
+                });
+            }
+        }
+        return;
+    }
+    if (options.addSlack) {
+        const hook = await hooks.addHook(hookTemplates.slack(options.addSlack));
+        console.log(chalk.green(`✅ Added Slack hook: ${hook.id}`));
+        return;
+    }
+    if (options.addTeams) {
+        const hook = await hooks.addHook(hookTemplates.teams(options.addTeams));
+        console.log(chalk.green(`✅ Added Teams hook: ${hook.id}`));
+        return;
+    }
+    if (options.remove) {
+        await hooks.removeHook(options.remove);
+        console.log(chalk.green(`✅ Removed hook: ${options.remove}`));
+        return;
+    }
+    if (options.toggle) {
+        await hooks.toggleHook(options.toggle);
+        console.log(chalk.green(`✅ Toggled hook: ${options.toggle}`));
+        return;
+    }
+    // Show help if no action
+    console.log(chalk.bold.cyan('\n🔔 Hooks Management\n'));
+    console.log(chalk.gray('  --list              List all hooks'));
+    console.log(chalk.gray('  --add-slack <url>   Add Slack webhook'));
+    console.log(chalk.gray('  --add-teams <url>   Add Teams webhook'));
+    console.log(chalk.gray('  --remove <id>       Remove hook'));
+    console.log(chalk.gray('  --toggle <id>       Toggle hook on/off'));
+});
+// Parse arguments
+const args = process.argv.slice(2);
+// Handle slash commands (e.g., /help, /analyze)
+const slashCommandMap = {
+    '/help': 'help',
+    '/h': 'help',
+    '/analyze': 'analyze',
+    '/a': 'analyze',
+    '/status': 'status',
+    '/st': 'status',
+    '/init': 'init',
+    '/i': 'init',
+    '/login': 'login',
+    '/logout': 'logout',
+    '/whoami': 'whoami',
+    '/me': 'whoami',
+    '/config': 'config',
+    '/dashboard': 'dashboard',
+    '/ui': 'dashboard',
+    '/sync': 'sync',
+    '/deploy': 'deploy',
+    '/plugins': 'plugins',
+    '/version': '--version',
+    '/v': '--version',
+};
+// Convert slash commands to regular commands
+if (args.length > 0 && args[0].startsWith('/')) {
+    const slashCmd = args[0].toLowerCase();
+    const mappedCmd = slashCommandMap[slashCmd];
+    if (mappedCmd) {
+        if (mappedCmd.startsWith('--')) {
+            // It's a flag like --version
+            args[0] = mappedCmd;
+        }
+        else {
+            // It's a command
+            args[0] = mappedCmd;
+        }
+    }
+    else {
+        // Unknown slash command
+        console.error(chalk.red(`❌ Unknown command: ${slashCmd}`));
+        console.log(chalk.gray('Run /help to see available commands'));
+        process.exit(1);
+    }
+}
+const parsed = program.parse(['node', 'delta', ...args]);
+// If no command provided and not in interactive mode, show welcome
+if (process.argv.length <= 2 && !parsed.opts().interactive) {
+    printWelcome();
+    printTips();
+}
+// Run interactive mode if requested
+if (parsed.opts().interactive) {
+    printWelcome();
+    runInteractiveMode({});
+}
+//# sourceMappingURL=index.js.map