ultra-dex 3.1.0 → 3.3.0

package/lib/utils/browser.js

@@ -0,0 +1,373 @@
+/**
+ * Browser Automation Module (Playwright-based)
+ * Enables Research agent to browse the web, take screenshots, and interact with pages
+ * This is what makes Ultra-Dex truly intelligent - it can LEARN from the web
+ */
+
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import path from 'path';
+
+// ============================================================================
+// BROWSER CONFIGURATION
+// ============================================================================
+
+const BROWSER_CONFIG = {
+  // Default browser settings
+  headless: true,
+  timeout: 30000,
+  viewport: { width: 1280, height: 720 },
+
+  // Screenshot settings
+  screenshotDir: '.ultra-dex/screenshots',
+
+  // User agent
+  userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Ultra-Dex/3.2.0 Research Agent',
+
+  // Blocked resources (for faster loading)
+  blockedResources: ['image', 'stylesheet', 'font', 'media'],
+};
+
+// ============================================================================
+// BROWSER AUTOMATION CLASS
+// ============================================================================
+
+/**
+ * Browser automation for Research agent
+ * Uses Playwright for reliable cross-browser automation
+ */
+export class BrowserAutomation {
+  constructor(options = {}) {
+    this.options = { ...BROWSER_CONFIG, ...options };
+    this.browser = null;
+    this.context = null;
+    this.page = null;
+    this.playwright = null;
+  }
+
+  /**
+   * Launch browser
+   */
+  async launch() {
+    try {
+      // Dynamic import of playwright
+      const { chromium } = await import('playwright');
+      this.playwright = { chromium };
+
+      this.browser = await chromium.launch({
+        headless: this.options.headless,
+      });
+
+      this.context = await this.browser.newContext({
+        userAgent: this.options.userAgent,
+        viewport: this.options.viewport,
+      });
+
+      // Block unnecessary resources for faster loading
+      if (this.options.blockedResources.length > 0) {
+        await this.context.route('**/*', (route) => {
+          if (this.options.blockedResources.includes(route.request().resourceType())) {
+            route.abort();
+          } else {
+            route.continue();
+          }
+        });
+      }
+
+      this.page = await this.context.newPage();
+      this.page.setDefaultTimeout(this.options.timeout);
+
+      return true;
+    } catch (err) {
+      console.log(chalk.yellow(`Browser launch failed: ${err.message}`));
+      console.log(chalk.gray('Install Playwright: npm install playwright'));
+      return false;
+    }
+  }
+
+  /**
+   * Close browser
+   */
+  async close() {
+    if (this.browser) {
+      await this.browser.close();
+      this.browser = null;
+      this.context = null;
+      this.page = null;
+    }
+  }
+
+  /**
+   * Navigate to URL
+   */
+  async navigate(url) {
+    if (!this.page) {
+      await this.launch();
+    }
+
+    await this.page.goto(url, { waitUntil: 'domcontentloaded' });
+    return { url: this.page.url(), title: await this.page.title() };
+  }
+
+  /**
+   * Get page content (text extraction)
+   */
+  async getPageContent(url) {
+    await this.navigate(url);
+
+    // Extract text content
+    const content = await this.page.evaluate(() => {
+      // Remove scripts and styles
+      const scripts = document.querySelectorAll('script, style, noscript');
+      scripts.forEach(el => el.remove());
+
+      // Get main content areas
+      const mainContent = document.querySelector('main, article, .content, #content, .main');
+      const target = mainContent || document.body;
+
+      // Extract text
+      const text = target.innerText || target.textContent || '';
+
+      // Clean up whitespace
+      return text
+        .replace(/\s+/g, ' ')
+        .replace(/\n\s*\n/g, '\n')
+        .trim()
+        .substring(0, 50000); // Limit content size
+    });
+
+    // Extract links
+    const links = await this.page.evaluate(() => {
+      return Array.from(document.querySelectorAll('a[href]'))
+        .slice(0, 50)
+        .map(a => ({
+          text: a.innerText?.trim().substring(0, 100),
+          href: a.href,
+        }))
+        .filter(l => l.text && l.href.startsWith('http'));
+    });
+
+    // Extract headings
+    const headings = await this.page.evaluate(() => {
+      return Array.from(document.querySelectorAll('h1, h2, h3'))
+        .slice(0, 20)
+        .map(h => ({
+          level: h.tagName.toLowerCase(),
+          text: h.innerText?.trim().substring(0, 200),
+        }))
+        .filter(h => h.text);
+    });
+
+    return {
+      url: this.page.url(),
+      title: await this.page.title(),
+      content: content.substring(0, 20000), // Limit for context window
+      headings,
+      links: links.slice(0, 20),
+      wordCount: content.split(/\s+/).length,
+    };
+  }
+
+  /**
+   * Take screenshot
+   */
+  async screenshot(url, options = {}) {
+    await this.navigate(url);
+
+    const { fullPage = false, path: customPath } = options;
+
+    // Ensure screenshot directory exists
+    await fs.mkdir(this.options.screenshotDir, { recursive: true });
+
+    // Generate filename
+    const timestamp = Date.now();
+    const filename = customPath || path.join(
+      this.options.screenshotDir,
+      `screenshot-${timestamp}.png`
+    );
+
+    await this.page.screenshot({
+      path: filename,
+      fullPage,
+    });
+
+    return {
+      path: filename,
+      url: this.page.url(),
+      title: await this.page.title(),
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  /**
+   * Click an element
+   */
+  async click(selector) {
+    await this.page.click(selector);
+    await this.page.waitForLoadState('domcontentloaded');
+
+    return {
+      clicked: selector,
+      url: this.page.url(),
+      title: await this.page.title(),
+    };
+  }
+
+  /**
+   * Fill a form field
+   */
+  async fill(selector, value) {
+    await this.page.fill(selector, value);
+
+    return {
+      filled: selector,
+      value: value.substring(0, 50), // Don't expose full value
+    };
+  }
+
+  /**
+   * Wait for selector
+   */
+  async waitFor(selector, options = {}) {
+    const { timeout = 10000, state = 'visible' } = options;
+
+    try {
+      await this.page.waitForSelector(selector, { timeout, state });
+      return { success: true, selector };
+    } catch {
+      return { success: false, selector, error: 'Timeout waiting for element' };
+    }
+  }
+
+  /**
+   * Execute JavaScript on page
+   */
+  async evaluate(script) {
+    const result = await this.page.evaluate(script);
+    return { result };
+  }
+
+  /**
+   * Get page metadata
+   */
+  async getMetadata(url) {
+    await this.navigate(url);
+
+    const metadata = await this.page.evaluate(() => {
+      const getMeta = (name) => {
+        const el = document.querySelector(`meta[name="${name}"], meta[property="${name}"]`);
+        return el?.getAttribute('content') || null;
+      };
+
+      return {
+        title: document.title,
+        description: getMeta('description') || getMeta('og:description'),
+        keywords: getMeta('keywords'),
+        author: getMeta('author'),
+        ogImage: getMeta('og:image'),
+        ogTitle: getMeta('og:title'),
+        canonical: document.querySelector('link[rel="canonical"]')?.href,
+      };
+    });
+
+    return { url: this.page.url(), ...metadata };
+  }
+
+  /**
+   * Search Google and get results
+   */
+  async searchGoogle(query) {
+    const searchUrl = `https://www.google.com/search?q=${encodeURIComponent(query)}`;
+    await this.navigate(searchUrl);
+
+    // Wait for results
+    await this.page.waitForSelector('#search', { timeout: 10000 }).catch(() => {});
+
+    const results = await this.page.evaluate(() => {
+      const items = document.querySelectorAll('#search .g');
+      return Array.from(items).slice(0, 10).map(item => {
+        const linkEl = item.querySelector('a');
+        const titleEl = item.querySelector('h3');
+        const snippetEl = item.querySelector('.VwiC3b');
+
+        return {
+          title: titleEl?.innerText || '',
+          url: linkEl?.href || '',
+          snippet: snippetEl?.innerText || '',
+        };
+      }).filter(r => r.url && r.title);
+    });
+
+    return { query, results };
+  }
+
+  /**
+   * Fetch documentation from common sources
+   */
+  async fetchDocs(library, topic = '') {
+    const docSources = {
+      react: 'https://react.dev/reference',
+      nextjs: 'https://nextjs.org/docs',
+      prisma: 'https://www.prisma.io/docs',
+      typescript: 'https://www.typescriptlang.org/docs',
+      tailwind: 'https://tailwindcss.com/docs',
+      node: 'https://nodejs.org/docs/latest/api',
+    };
+
+    const baseUrl = docSources[library.toLowerCase()];
+    if (!baseUrl) {
+      // Fall back to Google search
+      return this.searchGoogle(`${library} ${topic} documentation`);
+    }
+
+    const url = topic ? `${baseUrl}/${topic}` : baseUrl;
+    return this.getPageContent(url);
+  }
+}
+
+// ============================================================================
+// LIGHTWEIGHT FETCH (No Browser)
+// ============================================================================
+
+/**
+ * Simple HTTP fetch for when browser is overkill
+ */
+export async function simpleFetch(url) {
+  const response = await fetch(url, {
+    headers: {
+      'User-Agent': BROWSER_CONFIG.userAgent,
+    },
+  });
+
+  const contentType = response.headers.get('content-type') || '';
+
+  if (contentType.includes('application/json')) {
+    return { type: 'json', data: await response.json() };
+  }
+
+  const text = await response.text();
+
+  // Simple HTML to text conversion
+  if (contentType.includes('text/html')) {
+    const cleaned = text
+      .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
+      .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, '')
+      .replace(/<[^>]+>/g, ' ')
+      .replace(/\s+/g, ' ')
+      .trim();
+
+    return { type: 'html', data: cleaned.substring(0, 50000) };
+  }
+
+  return { type: 'text', data: text.substring(0, 50000) };
+}
+
+// ============================================================================
+// EXPORTS
+// ============================================================================
+
+export default {
+  BrowserAutomation,
+  simpleFetch,
+  BROWSER_CONFIG,
+};

package/lib/utils/help.js

@@ -0,0 +1,64 @@
+import chalk from 'chalk';
+import gradient from 'gradient-string';
+import { isDoomsdayMode } from './theme-state.js';
+import { showHelp as showDoomsdayHelp } from '../themes/doomsday.js';
+
+const ultraGradient = gradient(['#6366f1', '#8b5cf6', '#d946ef']);
+
+export function showHelp() {
+  if (isDoomsdayMode()) {
+    return showDoomsdayHelp();
+  }
+
+  console.log('');
+  console.log(ultraGradient('  ═══════════════════════════════════════════════'));
+  console.log(ultraGradient('  ║        U L T R A - D E X  :  O R C H E S T R A T I O N'));
+  console.log(ultraGradient('  ═══════════════════════════════════════════════'));
+  console.log('');
+  
+  const sections = [
+    {
+      title: '🚀 PROJECT SETUP',
+      commands: [
+        ['init', 'Initialize new project'],
+        ['generate', 'Generate implementation plan'],
+        ['swarm', 'Run agent pipeline']
+      ]
+    },
+    {
+      title: '🛡️ QUALITY & DEFENSE',
+      commands: [
+        ['review', 'Run code review'],
+        ['validate', 'Check project integrity'],
+        ['hooks', 'Install git hooks']
+      ]
+    },
+    {
+      title: '⚡ ACTIVE KERNEL',
+      commands: [
+        ['serve', 'Start MCP server & dashboard'],
+        ['dashboard', 'Open web dashboard'],
+        ['agents', 'List available agents']
+      ]
+    },
+    {
+      title: '📦 DEPLOYMENT',
+      commands: [
+        ['build', 'Execute next task'],
+        ['deploy', 'Deploy application'],
+        ['doctor', 'System diagnostics']
+      ]
+    }
+  ];
+  
+  sections.forEach(section => {
+    console.log(`  ${chalk.hex('#8b5cf6').bold(section.title)}`);
+    section.commands.forEach(([cmd, desc]) => {
+      console.log(`    ${chalk.hex('#6366f1')(cmd.padEnd(16))} ${chalk.dim(desc)}`);
+    });
+    console.log('');
+  });
+  
+  console.log(chalk.dim('  "AI Orchestration Meta-Layer for Professional SaaS Development"'));
+  console.log('');
+}

package/lib/utils/messages.js

@@ -0,0 +1,35 @@
+// cli/lib/utils/messages.js
+export const professionalMessages = {
+  start: [
+    "AI Orchestration initialized. Ready for mission.",
+    "Analyzing project graph for optimal path...",
+    "System check complete. Starting task execution.",
+    "Leveraging 16 specialized agents for development."
+  ],
+  
+  success: [
+    "✓ Task completed successfully. Alignment verified.",
+    "✓ System integrity confirmed. Code merged.",
+    "✓ Orchestration successful. Results saved.",
+    "✓ Professional SaaS standards achieved."
+  ],
+  
+  error: [
+    "✕ Task failed. Analyzing logs for recovery...",
+    "✕ System anomaly detected. Diagnostic required.",
+    "✕ Orchestration interrupted. Please check configuration.",
+    "✕ Quality gate failed. Refactoring recommended."
+  ],
+  
+  loading: [
+    "Initializing agent pipeline...",
+    "Scanning project context...",
+    "Optimizing orchestration logic...",
+    "Verifying system state..."
+  ]
+};
+
+export function getRandomMessage(type) {
+  const messages = professionalMessages[type];
+  return messages[Math.floor(Math.random() * messages.length)];
+}

package/lib/utils/progress.js

@@ -0,0 +1,24 @@
+import chalk from 'chalk';
+import ora from 'ora';
+
+export function showProgress(tasks) {
+  const total = tasks.length;
+  console.log('');
+  console.log(chalk.hex('#8b5cf6').bold('  ⚡ EXECUTING TASKS...'));
+  console.log('');
+  
+  tasks.forEach((task, idx) => {
+    // Simple vertical list for now
+    console.log(`  ${chalk.hex('#d946ef')('►')} ${task}`);
+  });
+  console.log('');
+}
+
+export function progressBar(current, total, width = 40) {
+  const percentage = Math.round((current / total) * 100);
+  const filled = Math.round((current / total) * width);
+  const empty = width - filled;
+
+  const bar = chalk.hex('#6366f1')('█'.repeat(filled)) + chalk.dim('░'.repeat(empty));
+  return `${bar} ${chalk.hex('#d946ef')(percentage + '%')}`;
+}

package/lib/utils/prompts.js

@@ -0,0 +1,47 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import gradient from 'gradient-string';
+
+export async function selectAgent() {
+  const agents = [
+    { name: '🏛️  CTO - Architecture decisions', value: 'cto' },
+    { name: '📋  Planner - Task breakdown', value: 'planner' },
+    { name: '🔧  Backend - API & server', value: 'backend' },
+    { name: '🎨  Frontend - UI components', value: 'frontend' },
+    { name: '💾  Database - Schema & queries', value: 'database' },
+    { name: '🔐  Auth - Authentication', value: 'auth' },
+    { name: '🛡️  Security - Security review', value: 'security' },
+    { name: '📝  Testing - Write tests', value: 'testing' },
+    { name: '📖  Docs - Documentation', value: 'documentation' },
+    { name: '👀  Reviewer - Code review', value: 'reviewer' }
+  ];
+  const { agent } = await inquirer.prompt([{
+    type: 'list',
+    name: 'agent',
+    message: gradient(['#6366f1', '#8b5cf6'])('Select an agent:'),
+    choices: agents,
+    pageSize: 12
+  }]);
+  
+  return agent;
+}
+
+export async function confirmAction(message) {
+  const { confirm } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'confirm',
+    message: chalk.yellow(message),
+    default: false
+  }]);
+  return confirm;
+}
+
+export async function inputText(message, defaultValue = '') {
+  const { value } = await inquirer.prompt([{
+    type: 'input',
+    name: 'value',
+    message: chalk.cyan(message),
+    default: defaultValue
+  }]);
+  return value;
+}

package/lib/utils/spinners.js

@@ -0,0 +1,46 @@
+import ora from 'ora';
+import chalk from 'chalk';
+
+const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+export function createSpinner(text) {
+  return ora({
+    text: chalk.cyan(text),
+    spinner: {
+      interval: 80,
+      frames: spinnerFrames
+    },
+    color: 'magenta'
+  });
+}
+
+export function success(text) {
+  return ora().succeed(chalk.green(text));
+}
+
+export function fail(text) {
+  return ora().fail(chalk.red(text));
+}
+
+export function info(text) {
+  return ora().info(chalk.blue(text));
+}
+
+export function warn(text) {
+  return ora().warn(chalk.yellow(text));
+}
+
+// Task list with progress
+export async function runTasks(tasks) {
+  for (const task of tasks) {
+    const spinner = createSpinner(task.title);
+    spinner.start();
+    try {
+      await task.fn();
+      spinner.succeed(chalk.green(task.title));
+    } catch (error) {
+      spinner.fail(chalk.red(`${task.title}: ${error.message}`));
+      throw error;
+    }
+  }
+}

package/lib/utils/status.js

@@ -0,0 +1,31 @@
+import chalk from 'chalk';
+import figures from 'figures';
+
+export const icons = {
+  success: chalk.hex('#22c55e')(figures.tick),
+  error: chalk.hex('#ef4444')(figures.cross),
+  warning: chalk.hex('#f59e0b')(figures.warning),
+  info: chalk.hex('#6366f1')(figures.info),
+  pending: chalk.hex('#6b7280')(figures.circle),
+  running: chalk.hex('#d946ef')(figures.play),
+  pointer: chalk.hex('#8b5cf6')(figures.pointer),
+  bullet: chalk.dim(figures.bullet)
+};
+
+export function showInfinityStatus() {
+  // Deprecated function, kept for compatibility if called elsewhere but showing nothing or simple status
+}
+
+export function statusLine(icon, text) {
+  console.log(`  ${icon} ${text}`);
+}
+
+export function header(text) {
+  console.log('');
+  console.log(chalk.bold.hex('#8b5cf6')(`  ${text}`));
+  console.log(chalk.dim('  ' + '─'.repeat(50)));
+}
+
+export function separator() {
+  console.log('');
+}

package/lib/utils/tables.js

@@ -0,0 +1,41 @@
+import Table from 'cli-table3';
+import chalk from 'chalk';
+import gradient from 'gradient-string';
+
+export function createTable(headers, rows) {
+  const table = new Table({
+    head: headers.map(h => gradient(['#6366f1', '#8b5cf6'])(h)),
+    chars: {
+      'top': '─', 'top-mid': '┬', 'top-left': '╭', 'top-right': '╮',
+      'bottom': '─', 'bottom-mid': '┴', 'bottom-left': '╰', 'bottom-right': '╯',
+      'left': '│', 'left-mid': '├', 'mid': '─', 'mid-mid': '┼',
+      'right': '│', 'right-mid': '┤', 'middle': '│'
+    },
+    style: {
+      head: ['magenta'],
+      border: ['dim']
+    }
+  });
+  
+  rows.forEach(row => table.push(row));
+  return table.toString();
+}
+
+export function showAgentsTable(agents) {
+  const headers = ['Tier', 'Agent', 'Status'];
+  const rows = agents.map(a => [
+    chalk.dim(a.tier || 'N/A'),
+    chalk.cyan(a.name),
+    a.status === 'ready' ? chalk.green('●') : chalk.yellow('○')
+  ]);
+  console.log(createTable(headers, rows));
+}
+
+export function showCommandsTable(commands) {
+  const headers = ['Command', 'Description'];
+  const rows = commands.map(c => [
+    chalk.cyan(c.name),
+    chalk.dim(c.description)
+  ]);
+  console.log(createTable(headers, rows));
+}

package/lib/utils/theme-state.js

@@ -0,0 +1,9 @@
+export let isDoomsday = false;
+
+export function setDoomsdayMode(enabled) {
+  isDoomsday = enabled;
+}
+
+export function isDoomsdayMode() {
+  return isDoomsday;
+}