@vee-stack/delta-cli 2.0.4 → 2.0.5

package/dist/index.js

@@ -0,0 +1,387 @@
+#!/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';
+// 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 { loadConfig } from './commands/auth.js';
+import { SecureTokenStore } from './auth/secure-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 hasPat = await SecureTokenStore.hasTokens();
+    const config = {
+        defaultProvider: 'local',
+        providers: {
+            local: {
+                enabled: true,
+                maxFileSize: 10 * 1024 * 1024, // 10MB
+                excludePatterns: ['node_modules', 'dist', '.git', 'coverage'],
+            },
+            remote: {
+                enabled: hasPat,
+                apiUrl: auth.apiUrl || 'http://localhost:3000',
+                timeout: 30000,
+                retryAttempts: 3,
+            },
+            ai: {
+                enabled: false, // Reserved for future
+                provider: 'openai',
+            },
+        },
+        features: {
+            cache: true,
+            offlineMode: !hasPat,
+            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 - Simplified (no --interactive)
+program
+    .option('--no-color', 'Disable colored output', false)
+    .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 - Simplified CLI (no TUI)
+program
+    .command('analyze [path]')
+    .alias('a')
+    .description('🔍 Run code analysis and optionally upload to cloud')
+    .option('-f, --format <type>', 'Output format: json, html, markdown', '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', '10485760')
+    .option('--upload', 'Upload report to Delta cloud', false)
+    .option('--project-name <name>', 'Project name for the report')
+    .option('--json', 'Output results as JSON', false)
+    .action(async (path, options) => {
+    const { analyzeCommand } = await import('./commands/analyze.js');
+    await analyzeCommand(path || '.', {
+        format: options.format,
+        output: options.output,
+        include: options.include?.join(','),
+        exclude: options.exclude?.join(','),
+        maxSize: options.maxSize,
+        upload: options.upload,
+        projectName: options.projectName,
+    });
+});
+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')
+    .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));
+    }
+});
+// Parse arguments
+const args = process.argv.slice(2);
+// Handle slash commands (simplified)
+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',
+    '/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);
+    }
+}
+program.parse(['node', 'delta', ...args]);
+// If no command provided, show welcome and help
+if (process.argv.length <= 2) {
+    printWelcome();
+    printTips();
+    program.help();
+}
+//# sourceMappingURL=index.js.map

package/dist/interactive/index.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { DeltaApp } from '../components/DeltaApp.js';
+import { UnifiedManager } from '../components/UnifiedManager.js';
+export async function runInteractiveMode(options) {
+    // Render the React Ink app
+    const Component = options.mode === 'manager' ? UnifiedManager : DeltaApp;
+    const { waitUntilExit } = render(_jsx(Component, {}));
+    await waitUntilExit();
+}
+//# sourceMappingURL=index.js.map

package/dist/packages/domain/src/constitution/contracts/index.js

@@ -0,0 +1,43 @@
+/**
+ * Delta Constitution - Contracts Rules Index
+ * @description Contract rules for all supported languages
+ * @version 1.0.0
+ */
+// TypeScript / Node.js Rules
+export { default as ts, ContractsRules as TSContractsRules } from './ts.rules';
+// Language-agnostic exports
+export const ContractsAxis = {
+    name: 'Contracts',
+    description: 'Type-safe, versioned interfaces between layers',
+    weight: 15,
+    languages: ['typescript', 'javascript', 'node'],
+    principles: [
+        {
+            id: 'CONTRACT-001',
+            name: 'One Contract Per Module',
+            description: 'Every module must export a corresponding contract',
+        },
+        {
+            id: 'CONTRACT-002',
+            name: 'Features Use Contracts Only',
+            description: 'Features can only import from Contracts, not Modules directly',
+        },
+        {
+            id: 'CONTRACT-003',
+            name: 'Semantic Versioning',
+            description: 'Contracts follow semver: major.breaking, minor.feature, patch.fix',
+        },
+        {
+            id: 'CONTRACT-004',
+            name: 'Interface Design',
+            description: 'Clear naming, required/optional fields, documentation',
+        },
+        {
+            id: 'CONTRACT-005',
+            name: 'Validation',
+            description: 'Runtime validation with Zod schemas',
+        },
+    ],
+};
+export default ContractsAxis;
+//# sourceMappingURL=index.js.map