ultra-dex 1.8.0 → 2.2.1

package/lib/commands/fetch.js

@@ -0,0 +1,186 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs/promises';
+import path from 'path';
+import { GITHUB_RAW_BASE } from '../config/urls.js';
+import { fetchWithRetry } from '../utils/network.js';
+import { validateSafePath } from '../utils/validation.js';
+
+async function downloadFile(url, destPath) {
+  try {
+    const response = await fetchWithRetry(url);
+    const content = await response.text();
+    await fs.mkdir(path.dirname(destPath), { recursive: true });
+    await fs.writeFile(destPath, content);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+export function registerFetchCommand(program) {
+  program
+    .command('fetch')
+    .description('Download all Ultra-Dex assets for offline use')
+    .option('-d, --dir <directory>', 'Target directory', '.ultra-dex')
+    .option('--agents', 'Fetch only agent prompts')
+    .option('--rules', 'Fetch only cursor rules')
+    .option('--docs', 'Fetch only documentation')
+    .action(async (options) => {
+      console.log(chalk.cyan('\n📦 Ultra-Dex Asset Fetcher\n'));
+
+      const dirValidation = validateSafePath(options.dir, 'Target directory');
+      if (dirValidation !== true) {
+        console.log(chalk.red(dirValidation));
+        process.exit(1);
+      }
+
+      const targetDir = path.resolve(options.dir);
+      const fetchAll = !options.agents && !options.rules && !options.docs;
+
+      const spinner = ora('Preparing to fetch assets...').start();
+
+      await fs.mkdir(targetDir, { recursive: true });
+
+      let downloaded = 0;
+      let failed = 0;
+
+      if (fetchAll || options.rules) {
+        spinner.text = 'Fetching cursor rules...';
+        const rulesDir = path.join(targetDir, 'cursor-rules');
+        await fs.mkdir(rulesDir, { recursive: true });
+
+        const ruleFiles = [
+          '00-ultra-dex-core.mdc',
+          '01-database.mdc',
+          '02-api.mdc',
+          '03-auth.mdc',
+          '04-frontend.mdc',
+          '05-payments.mdc',
+          '06-testing.mdc',
+          '07-security.mdc',
+          '08-deployment.mdc',
+          '09-error-handling.mdc',
+          '10-performance.mdc',
+          '11-nextjs-v15.mdc',
+          '12-multi-tenancy.mdc',
+        ];
+
+        for (const file of ruleFiles) {
+          const url = `${GITHUB_RAW_BASE}/cursor-rules/${file}`;
+          const dest = path.join(rulesDir, file);
+          if (await downloadFile(url, dest)) {
+            downloaded++;
+          } else {
+            failed++;
+          }
+        }
+
+        await downloadFile(`${GITHUB_RAW_BASE}/cursor-rules/load.sh`, path.join(rulesDir, 'load.sh'));
+        try {
+          await fs.chmod(path.join(rulesDir, 'load.sh'), '755');
+        } catch {}
+      }
+
+      if (fetchAll || options.agents) {
+        spinner.text = 'Fetching agent prompts...';
+        const agentsDir = path.join(targetDir, 'agents');
+
+        const agentPaths = [
+          '00-AGENT_INDEX.md',
+          'README.md',
+          'AGENT-INSTRUCTIONS.md',
+          '1-leadership/cto.md',
+          '1-leadership/planner.md',
+          '1-leadership/research.md',
+          '2-development/backend.md',
+          '2-development/frontend.md',
+          '2-development/database.md',
+          '3-security/security.md',
+          '4-devops/devops.md',
+          '5-quality/reviewer.md',
+          '5-quality/testing.md',
+          '5-quality/debugger.md',
+          '6-specialist/performance.md',
+          '6-specialist/refactoring.md',
+          '6-specialist/documentation.md',
+        ];
+
+        for (const agentPath of agentPaths) {
+          const url = `${GITHUB_RAW_BASE}/agents/${agentPath}`;
+          const dest = path.join(agentsDir, agentPath);
+          if (await downloadFile(url, dest)) {
+            downloaded++;
+          } else {
+            failed++;
+          }
+        }
+      }
+
+      if (fetchAll || options.docs) {
+        spinner.text = 'Fetching documentation...';
+        const docsDir = path.join(targetDir, 'docs');
+
+        const docFiles = [
+          'VERIFICATION.md',
+          'BUILD-AUTH-30M.md',
+          'QUICK-REFERENCE.md',
+          'TROUBLESHOOTING.md',
+        ];
+
+        for (const file of docFiles) {
+          const url = `${GITHUB_RAW_BASE}/docs/${file}`;
+          const dest = path.join(docsDir, file);
+          if (await downloadFile(url, dest)) {
+            downloaded++;
+          } else {
+            failed++;
+          }
+        }
+
+        const guidesDir = path.join(targetDir, 'guides');
+        const guideFiles = [
+          'PROJECT-ORCHESTRATION.md',
+          'ADVANCED-WORKFLOWS.md',
+          'DATABASE-DECISION-FRAMEWORK.md',
+          'ARCHITECTURE-PATTERNS.md',
+        ];
+
+        for (const file of guideFiles) {
+          const url = `${GITHUB_RAW_BASE}/guides/${file}`;
+          const dest = path.join(guidesDir, file);
+          if (await downloadFile(url, dest)) {
+            downloaded++;
+          } else {
+            failed++;
+          }
+        }
+      }
+
+      if (failed === 0) {
+        spinner.succeed(chalk.green(`Downloaded ${downloaded} files to ${targetDir}`));
+      } else {
+        spinner.warn(chalk.yellow(`Downloaded ${downloaded} files, ${failed} failed`));
+      }
+
+      console.log(chalk.bold('\n📁 Assets downloaded to:\n'));
+      if (fetchAll || options.rules) {
+        console.log(chalk.gray(`  ${targetDir}/cursor-rules/  (12 .mdc files)`));
+      }
+      if (fetchAll || options.agents) {
+        console.log(chalk.gray(`  ${targetDir}/agents/        (16 agent prompts)`));
+      }
+      if (fetchAll || options.docs) {
+        console.log(chalk.gray(`  ${targetDir}/docs/          (documentation)`));
+        console.log(chalk.gray(`  ${targetDir}/guides/        (guides)`));
+      }
+
+      console.log(chalk.bold('\n💡 Usage:\n'));
+      console.log(chalk.cyan('  # Copy cursor rules to project'));
+      console.log(chalk.gray(`  cp -r ${targetDir}/cursor-rules .cursor/rules`));
+      console.log(chalk.cyan('\n  # Copy agents to project'));
+      console.log(chalk.gray(`  cp -r ${targetDir}/agents .agents`));
+      console.log(chalk.cyan('\n  # Works offline now!'));
+      console.log(chalk.gray('  No GitHub access needed after fetch.\n'));
+    });
+}

package/lib/commands/generate.js

@@ -0,0 +1,217 @@
+/**
+ * ultra-dex generate command
+ * Generates a full 34-section implementation plan from an idea using AI
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import fs from 'fs/promises';
+import path from 'path';
+import { createProvider, getDefaultProvider, checkConfiguredProviders } from '../providers/index.js';
+import { SYSTEM_PROMPT, generateUserPrompt } from '../templates/prompts/generate-plan.js';
+
+export function registerGenerateCommand(program) {
+  program
+    .command('generate [idea]')
+    .description('Generate a full implementation plan from an idea using AI')
+    .option('-p, --provider <provider>', 'AI provider (claude, openai, gemini)')
+    .option('-m, --model <model>', 'Specific model to use')
+    .option('-o, --output <directory>', 'Output directory', '.')
+    .option('-k, --key <apiKey>', 'API key (or use environment variable)')
+    .option('--stream', 'Stream output in real-time', true)
+    .option('--no-stream', 'Disable streaming')
+    .action(async (idea, options) => {
+      console.log(chalk.cyan('\n🚀 Ultra-Dex Plan Generator\n'));
+
+      // Check configured providers
+      const configured = checkConfiguredProviders();
+      const hasProvider = configured.some(p => p.configured) || options.key;
+
+      if (!hasProvider) {
+        console.log(chalk.yellow('⚠️  No AI provider configured.\n'));
+        console.log(chalk.white('Set one of these environment variables:'));
+        configured.forEach(p => {
+          console.log(chalk.gray(`  export ${p.envKey}=your-key-here`));
+        });
+        console.log(chalk.white('\nOr use --key option:'));
+        console.log(chalk.gray('  npx ultra-dex generate "your idea" --key sk-...\n'));
+        return;
+      }
+
+      // Get idea if not provided
+      if (!idea) {
+        const answers = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'idea',
+            message: 'Describe your SaaS idea:',
+            validate: input => input.trim().length > 10 || 'Please provide a more detailed description',
+          },
+        ]);
+        idea = answers.idea;
+      }
+
+      // Select provider
+      const providerId = options.provider || getDefaultProvider();
+      if (!providerId) {
+        console.log(chalk.red('No provider available. Set an API key.'));
+        return;
+      }
+
+      console.log(chalk.gray(`Using provider: ${providerId}`));
+      console.log(chalk.gray(`Idea: "${idea}"\n`));
+
+      // Create provider instance
+      let provider;
+      try {
+        provider = createProvider(providerId, {
+          apiKey: options.key,
+          model: options.model,
+          maxTokens: 16000, // Large output for full plan
+        });
+      } catch (err) {
+        console.log(chalk.red(`Error: ${err.message}`));
+        return;
+      }
+
+      // Generate the plan
+      const spinner = ora('Generating your implementation plan...').start();
+      const startTime = Date.now();
+
+      try {
+        let result;
+        let planContent = '';
+
+        if (options.stream) {
+          spinner.stop();
+          console.log(chalk.cyan('📝 Generating plan:\n'));
+          console.log(chalk.gray('─'.repeat(60)));
+
+          result = await provider.generateStream(
+            SYSTEM_PROMPT,
+            generateUserPrompt(idea),
+            (chunk) => {
+              process.stdout.write(chunk);
+              planContent += chunk;
+            }
+          );
+
+          console.log(chalk.gray('\n' + '─'.repeat(60)));
+        } else {
+          result = await provider.generate(SYSTEM_PROMPT, generateUserPrompt(idea));
+          planContent = result.content;
+          spinner.succeed('Plan generated!');
+        }
+
+        // Calculate stats
+        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+        const cost = provider.estimateCost(result.usage.inputTokens, result.usage.outputTokens);
+
+        // Save the plan
+        const outputDir = path.resolve(options.output);
+        await fs.mkdir(outputDir, { recursive: true });
+
+        const planPath = path.join(outputDir, 'IMPLEMENTATION-PLAN.md');
+        const contextPath = path.join(outputDir, 'CONTEXT.md');
+        const quickStartPath = path.join(outputDir, 'QUICK-START.md');
+
+        // Add header to plan
+        const header = `# Implementation Plan
+
+> Generated by Ultra-Dex on ${new Date().toISOString().split('T')[0]}
+> Idea: "${idea}"
+
+---
+
+`;
+        await fs.writeFile(planPath, header + planContent);
+
+        // Generate CONTEXT.md
+        const contextContent = `# Project Context
+
+## Overview
+${idea}
+
+## Generated
+- Date: ${new Date().toISOString().split('T')[0]}
+- Provider: ${provider.getName()}
+- Model: ${provider.model}
+
+## Files
+- IMPLEMENTATION-PLAN.md - Full 34-section plan
+- QUICK-START.md - Quick reference
+- CONTEXT.md - This file
+
+## Usage
+Provide this context to any AI agent:
+\`\`\`
+Act as @Backend. Read CONTEXT.md and IMPLEMENTATION-PLAN.md first.
+Task: [your task]
+\`\`\`
+`;
+        await fs.writeFile(contextPath, contextContent);
+
+        // Generate QUICK-START.md
+        const quickStartContent = `# Quick Start
+
+## Your Idea
+${idea}
+
+## Next Steps
+
+1. **Review the plan**: Open IMPLEMENTATION-PLAN.md
+2. **Load into AI**: Copy CONTEXT.md to your AI tool
+3. **Start building**: Use \`npx ultra-dex build\` or paste prompts
+
+## Useful Commands
+
+\`\`\`bash
+npx ultra-dex build              # Start AI-assisted build
+npx ultra-dex review             # Check code against plan
+npx ultra-dex serve              # Serve context via HTTP
+npx ultra-dex agents             # List available agents
+\`\`\`
+
+## Agent Quick Start
+
+\`\`\`
+@Planner - Break down tasks
+@Backend - API endpoints
+@Frontend - UI components
+@Database - Schema design
+@Auth - Authentication
+@Testing - Write tests
+\`\`\`
+`;
+        await fs.writeFile(quickStartPath, quickStartContent);
+
+        // Print summary
+        console.log(chalk.green('\n✅ Plan generated successfully!\n'));
+        console.log(chalk.white('Files created:'));
+        console.log(chalk.gray(`  📄 ${planPath}`));
+        console.log(chalk.gray(`  📄 ${contextPath}`));
+        console.log(chalk.gray(`  📄 ${quickStartPath}`));
+
+        console.log(chalk.white('\nStats:'));
+        console.log(chalk.gray(`  ⏱️  Time: ${elapsed}s`));
+        console.log(chalk.gray(`  📊 Tokens: ${result.usage.inputTokens} in / ${result.usage.outputTokens} out`));
+        console.log(chalk.gray(`  💰 Cost: ~$${cost.total.toFixed(4)}`));
+
+        console.log(chalk.cyan('\n📋 Next steps:'));
+        console.log(chalk.white('  1. Review IMPLEMENTATION-PLAN.md'));
+        console.log(chalk.white('  2. Run: npx ultra-dex build'));
+        console.log(chalk.white('  3. Start coding with AI agents\n'));
+
+      } catch (err) {
+        spinner.fail('Generation failed');
+        console.log(chalk.red(`\nError: ${err.message}`));
+
+        if (err.message.includes('API')) {
+          console.log(chalk.yellow('\nTip: Check your API key and try again.'));
+        }
+      }
+    });
+}
+
+export default { registerGenerateCommand };

package/lib/commands/hooks.js

@@ -0,0 +1,105 @@
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import path from 'path';
+
+export function registerHooksCommand(program) {
+  program
+    .command('hooks')
+    .description('Set up git hooks for automated verification')
+    .option('--remove', 'Remove Ultra-Dex git hooks')
+    .action(async (options) => {
+      console.log(chalk.cyan('\n🪝 Ultra-Dex Git Hooks Setup\n'));
+
+      const gitDir = path.join(process.cwd(), '.git');
+      const hooksDir = path.join(gitDir, 'hooks');
+
+      try {
+        await fs.access(gitDir);
+      } catch {
+        console.log(chalk.red('❌ Not a git repository. Run "git init" first.\n'));
+        process.exit(1);
+      }
+
+      await fs.mkdir(hooksDir, { recursive: true });
+
+      const preCommitPath = path.join(hooksDir, 'pre-commit');
+
+      if (options.remove) {
+        try {
+          const content = await fs.readFile(preCommitPath, 'utf-8');
+          if (content.includes('ultra-dex')) {
+            await fs.unlink(preCommitPath);
+            console.log(chalk.green('✅ Ultra-Dex pre-commit hook removed.\n'));
+          } else {
+            console.log(chalk.yellow('⚠️  Pre-commit hook exists but is not from Ultra-Dex.\n'));
+          }
+        } catch {
+          console.log(chalk.gray('No Ultra-Dex hooks found.\n'));
+        }
+        return;
+      }
+
+      const preCommitScript = `#!/bin/sh
+# Ultra-Dex Pre-Commit Hook
+# Validates project structure before allowing commits
+# Remove with: npx ultra-dex hooks --remove
+
+echo "🔍 Ultra-Dex: Validating project structure..."
+
+# Run validation
+npx ultra-dex validate --dir . > /tmp/ultra-dex-validate.log 2>&1
+RESULT=$?
+
+if [ $RESULT -ne 0 ]; then
+  echo ""
+  echo "❌ Ultra-Dex validation failed. Commit blocked."
+  echo ""
+  echo "Run 'npx ultra-dex validate' to see details."
+  echo "Fix issues or bypass with: git commit --no-verify"
+  echo ""
+  exit 1
+fi
+
+# Check for required files
+if [ ! -f "QUICK-START.md" ]; then
+  echo "⚠️  Warning: QUICK-START.md not found"
+fi
+
+if [ ! -f "IMPLEMENTATION-PLAN.md" ]; then
+  echo "⚠️  Warning: IMPLEMENTATION-PLAN.md not found"
+fi
+
+echo "✅ Ultra-Dex validation passed."
+exit 0
+`;
+
+      try {
+        const existing = await fs.readFile(preCommitPath, 'utf-8');
+        if (existing.includes('ultra-dex')) {
+          console.log(chalk.yellow('⚠️  Ultra-Dex pre-commit hook already exists.\n'));
+          console.log(chalk.gray('  Use --remove to remove it first.\n'));
+          return;
+        } else {
+          const combined = existing + '\n\n' + preCommitScript;
+          await fs.writeFile(preCommitPath, combined);
+          await fs.chmod(preCommitPath, '755');
+          console.log(chalk.green('✅ Ultra-Dex hook appended to existing pre-commit.\n'));
+        }
+      } catch {
+        await fs.writeFile(preCommitPath, preCommitScript);
+        await fs.chmod(preCommitPath, '755');
+        console.log(chalk.green('✅ Pre-commit hook installed.\n'));
+      }
+
+      console.log(chalk.bold('What this does:\n'));
+      console.log(chalk.gray('  • Runs "ultra-dex validate" before each commit'));
+      console.log(chalk.gray('  • Blocks commits if required files are missing'));
+      console.log(chalk.gray('  • Warns about incomplete sections\n'));
+
+      console.log(chalk.bold('To bypass (not recommended):\n'));
+      console.log(chalk.cyan('  git commit --no-verify\n'));
+
+      console.log(chalk.bold('To remove:\n'));
+      console.log(chalk.cyan('  npx ultra-dex hooks --remove\n'));
+    });
+}