ultra-dex 2.2.1 → 3.2.0

package/lib/providers/ollama.js

@@ -0,0 +1,136 @@
+/**
+ * Ollama AI Provider (Local)
+ * Provides local intelligence for Ultra-Dex
+ */
+
+import { BaseProvider } from './base.js';
+
+const MODELS = [
+  { id: 'llama3:8b', name: 'Llama 3 (8B)', maxTokens: 8192, default: true },
+  { id: 'mistral', name: 'Mistral', maxTokens: 8192 },
+  { id: 'phi3', name: 'Phi-3', maxTokens: 4096 },
+  { id: 'codellama', name: 'CodeLlama', maxTokens: 8192 },
+];
+
+export class OllamaProvider extends BaseProvider {
+  constructor(apiKey, options = {}) {
+    // Ollama doesn't typically require an API key
+    super(apiKey || 'not-required', options);
+    this.baseUrl = options.baseUrl || 'http://localhost:11434/api';
+  }
+
+  getName() {
+    return 'Ollama (Local)';
+  }
+
+  getDefaultModel() {
+    return 'llama3:8b';
+  }
+
+  getAvailableModels() {
+    return MODELS;
+  }
+
+  estimateCost(inputTokens, outputTokens) {
+    // Local is free!
+    return {
+      input: 0,
+      output: 0,
+      total: 0,
+    };
+  }
+
+  async generate(systemPrompt, userPrompt, options = {}) {
+    const response = await fetch(`${this.baseUrl}/generate`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: this.model,
+        prompt: `${systemPrompt}\n\n${userPrompt}`,
+        stream: false,
+        options: {
+          num_predict: options.maxTokens || this.maxTokens,
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text().catch(() => response.statusText);
+      throw new Error(`Ollama API error: ${error}`);
+    }
+
+    const data = await response.json();
+    
+    return {
+      content: data.response || '',
+      usage: {
+        inputTokens: data.prompt_eval_count || 0,
+        outputTokens: data.eval_count || 0,
+      },
+    };
+  }
+
+  async generateStream(systemPrompt, userPrompt, onChunk, options = {}) {
+    const response = await fetch(`${this.baseUrl}/generate`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: this.model,
+        prompt: `${systemPrompt}\n\n${userPrompt}`,
+        stream: true,
+        options: {
+          num_predict: options.maxTokens || this.maxTokens,
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Ollama API error: ${response.statusText}`);
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let fullContent = '';
+    
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      const chunk = decoder.decode(value);
+      const lines = chunk.split('\n');
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed.response) {
+            fullContent += parsed.response;
+            onChunk(parsed.response);
+          }
+        } catch {
+          // Skip malformed JSON
+        }
+      }
+    }
+
+    return { 
+      content: fullContent, 
+      usage: { inputTokens: 0, outputTokens: 0 } // Ollama streaming usage is complex to track line by line
+    };
+  }
+
+  async validateApiKey() {
+    try {
+      const response = await fetch(`${this.baseUrl}/tags`);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+}
+
+export default OllamaProvider;

package/lib/providers/router.js

@@ -0,0 +1,63 @@
+/**
+ * Semantic Router AI Provider
+ * Routes tasks between local and cloud intelligence
+ */
+
+import { BaseProvider } from './base.js';
+
+export class RouterProvider extends BaseProvider {
+  constructor(apiKey, options = {}) {
+    super(apiKey, options);
+    this.localProvider = options.localProvider;
+    this.cloudProvider = options.cloudProvider;
+    this.threshold = options.threshold || 'medium'; // complexity threshold
+  }
+
+  getName() {
+    return `Semantic Router (${this.localProvider?.getName() || 'Local'} + ${this.cloudProvider?.getName() || 'Cloud'})`;
+  }
+
+  getDefaultModel() {
+    return 'router-v1';
+  }
+
+  async generate(systemPrompt, userPrompt, options = {}) {
+    const isComplex = this.assessComplexity(systemPrompt, userPrompt);
+    const provider = (isComplex || !this.localProvider) ? this.cloudProvider : this.localProvider;
+    
+    console.error(`[Router] Routing to ${provider.getName()} (Complexity: ${isComplex ? 'High' : 'Low'})`);
+    
+    return provider.generate(systemPrompt, userPrompt, options);
+  }
+
+  async generateStream(systemPrompt, userPrompt, onChunk, options = {}) {
+    const isComplex = this.assessComplexity(systemPrompt, userPrompt);
+    const provider = (isComplex || !this.localProvider) ? this.cloudProvider : this.localProvider;
+    
+    console.error(`[Router] Routing to ${provider.getName()} (Complexity: ${isComplex ? 'High' : 'Low'})`);
+    
+    return provider.generateStream(systemPrompt, userPrompt, onChunk, options);
+  }
+
+  assessComplexity(systemPrompt, userPrompt) {
+    const combined = (systemPrompt + userPrompt).toLowerCase();
+    
+    // Heuristics for "High Complexity"
+    const complexKeywords = [
+      'refactor', 'architect', 'security audit', 'design pattern', 
+      'migration', 'performance optimization', 'complex', 'fix the bug'
+    ];
+
+    const isComplexKeyword = complexKeywords.some(k => combined.includes(k));
+    const isLongPrompt = combined.length > 2000;
+    
+    return isComplexKeyword || isLongPrompt;
+  }
+
+  async validateApiKey() {
+    const cloudValid = await this.cloudProvider?.validateApiKey();
+    return !!cloudValid;
+  }
+}
+
+export default RouterProvider;

package/lib/quality/scanner.js

@@ -0,0 +1,128 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+// Define the Quality Rules
+const RULES = [
+  {
+    id: 'api-zod-validation',
+    name: 'API Input Validation',
+    description: 'API endpoints must validate input using Zod',
+    severity: 'error',
+    // Regex based pattern matching for file path
+    pattern: /app\/api\/.*\.ts|src\/routes\/.*\.ts|pages\/api\/.*\.ts/,
+    check: (content) => {
+      const isApi = /NextRequest|NextResponse|express\.Router|fastify/.test(content);
+      if (!isApi) return true;
+      return /import.*zod|require\(['"]zod['"]\)/.test(content);
+    },
+    message: 'API files must import "zod" for validation.'
+  },
+  {
+    id: 'no-explicit-any',
+    name: 'No Explicit Any',
+    description: 'Avoid using "any" type in TypeScript',
+    severity: 'warning',
+    pattern: /.*\.tsx?$/,
+    check: (content) => {
+      return !/:\s*any\b|<\s*any\s*>/.test(content);
+    },
+    message: 'Found explicit "any" type. Use unknown or a specific type.'
+  },
+  {
+    id: 'console-log-in-api',
+    name: 'No Console Log in Prod',
+    description: 'Use a logger instead of console.log in API routes',
+    severity: 'warning',
+    pattern: /app\/api\/.*|src\/routes\/.*/,
+    check: (content) => {
+      return !/console\.log\(/.test(content);
+    },
+    message: 'Found console.log in API. Use a proper logger or console.error/warn.'
+  },
+  {
+    id: 'secret-leak',
+    name: 'Secret Key Leak',
+    description: 'Do not commit secrets starting with sk_ or similar',
+    severity: 'critical',
+    pattern: /.*/,
+    check: (content) => {
+      // Obfuscate regex even further to avoid self-triggering on the string literals
+      const p1 = 'sk' + '_live' + '_';
+      const p2 = 'sk' + '_test' + '_';
+      const p3 = 'gh' + 'p_';
+      const p4 = 'ey' + 'J';
+      const pattern = new RegExp(`${p1}|${p2}|${p3}|${p4}`);
+      return !pattern.test(content);
+    },
+    message: 'Potential secret key detected!'
+  }
+];
+
+async function getFiles(dir) {
+  const dirents = await fs.readdir(dir, { withFileTypes: true });
+  const files = await Promise.all(dirents.map((dirent) => {
+    const res = path.resolve(dir, dirent.name);
+    if (dirent.isDirectory()) {
+      if (['node_modules', '.git', '.next', 'dist', 'build'].includes(dirent.name)) return [];
+      return getFiles(res);
+    }
+    return res;
+  }));
+  return files.flat();
+}
+
+export async function runQualityScan(dir) {
+  const results = {
+    passed: 0,
+    failed: 0,
+    warnings: 0,
+    filesScanned: 0,
+    details: []
+  };
+
+  const projectRoot = path.resolve(dir);
+  const allFiles = await getFiles(projectRoot);
+
+  for (const filePath of allFiles) {
+    // Relative path for pattern matching
+    const relativePath = path.relative(projectRoot, filePath);
+    
+    // Skip non-code/text files roughly
+    if (/\.(png|jpg|jpeg|gif|ico|woff|woff2|ttf|eot|pdf|lock)$/.test(filePath)) continue;
+
+    let content = '';
+    try {
+      content = await fs.readFile(filePath, 'utf8');
+    } catch { continue; }
+    
+    results.filesScanned++;
+
+    for (const rule of RULES) {
+      if (rule.pattern.test(relativePath) || rule.pattern.test(filePath)) { // Match against both just in case
+        try {
+          const passed = rule.check(content);
+          if (!passed) {
+            const issue = {
+              ruleId: rule.id,
+              ruleName: rule.name,
+              file: relativePath,
+              severity: rule.severity,
+              message: rule.message
+            };
+            results.details.push(issue);
+
+            if (rule.severity === 'error' || rule.severity === 'critical') {
+              results.failed++;
+            } else {
+              results.warnings++;
+            }
+          }
+        } catch (err) {
+          // Ignore check errors
+        }
+      }
+    }
+  }
+
+  return results;
+}

package/lib/swarm/coordinator.js

@@ -0,0 +1,97 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { runAgentLoop } from '../commands/run.js';
+import { createProvider, getDefaultProvider } from '../providers/index.js';
+import { loadState } from '../commands/plan.js';
+import fs from 'fs/promises';
+
+export class SwarmCoordinator {
+  constructor(provider, context) {
+    this.provider = provider;
+    this.context = context;
+    this.history = [];
+  }
+
+  async plan(feature) {
+    const spinner = ora('🧠 Hive Mind: Planning feature implementation...').start();
+    
+    // System prompt to force JSON output for the plan
+    const plannerPrompt = `
+You are the Hive Mind Planner.
+Your goal: Break down the feature "${feature}" into sequential atomic tasks for other agents.
+
+Available Agents:
+- @Backend (API, logic)
+- @Frontend (UI, React)
+- @Database (Schema, migrations)
+- @Auth (Authentication)
+- @Testing (Tests)
+
+Output STRICT JSON format only:
+{
+  "tasks": [
+    {
+      "id": 1,
+      "agent": "backend",
+      "task": "Create API endpoint for...",
+      "context": "Needs to handle..."
+    },
+    ...
+  ]
+}
+`;
+
+    try {
+      const result = await this.provider.generate(plannerPrompt, `Feature: ${feature}`);
+      
+      // Attempt to parse JSON (handling potential markdown code blocks)
+      let jsonStr = result.content.trim();
+      if (jsonStr.startsWith('```json')) {
+        jsonStr = jsonStr.replace(/^```json\n?/, '').replace(/\n?```$/, '');
+      } else if (jsonStr.startsWith('```')) {
+        jsonStr = jsonStr.replace(/^```\n?/, '').replace(/\n?```$/, '');
+      }
+
+      const plan = JSON.parse(jsonStr);
+      spinner.succeed(`Plan generated: ${plan.tasks.length} tasks identified.`);
+      return plan.tasks;
+    } catch (error) {
+      spinner.fail('Planning failed.');
+      console.error(chalk.red(error.message));
+      return null;
+    }
+  }
+
+  async execute(tasks) {
+    console.log(chalk.bold('\n🐝 Swarm Execution Started\n'));
+
+    for (const task of tasks) {
+      console.log(chalk.bold.cyan(`\n🔹 Step ${task.id}: [${task.agent.toUpperCase()}] ${task.task}`));
+      
+      // Inject previous history into context
+      const currentContext = {
+        ...this.context,
+        history: this.history.join('\n\n---\n\n')
+      };
+
+      try {
+        const output = await runAgentLoop(task.agent, task.task, this.provider, currentContext);
+        
+        // Save to history
+        this.history.push(`## Task ${task.id} (${task.agent})\n**Goal:** ${task.task}\n\n**Output:**\n${output}`);
+        
+        // Save artifact
+        const filename = `swarm-task-${task.id}-${task.agent}.md`;
+        await fs.writeFile(filename, output);
+        console.log(chalk.green(`   ✓ Output saved to ${filename}`));
+
+      } catch (error) {
+        console.log(chalk.red(`   ❌ Task failed: ${error.message}`));
+        // Decide whether to continue or stop
+        // For now, we continue
+      }
+    }
+
+    console.log(chalk.bold.green('\n✅ Swarm Mission Complete'));
+  }
+}