aegiscode 3.1.8 → 3.1.10

package/src/agent/orchestrator/utils.ts

@@ -0,0 +1,397 @@
+/**
+ * Orchestrator shared utilities
+ *
+ * Centralises model resolution, tool setup, and config construction
+ * so that every slash-command (/multi, /research, …) does not repeat
+ * the same boilerplate.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import { createChatService } from '../../services/ChatService.js';
+import { createToolRegistry, getBuiltinTools, ExecutionPipeline, PermissionMode } from '../../tools/index.js';
+import { configManager } from '../../config/ConfigManager.js';
+
+// ─── Types ────────────────────────────────────────────────────────
+
+export interface ResolvedModelConfig {
+  model: string;
+  baseURL?: string;
+  apiKey: string;
+  timeout: number;
+}
+
+export interface SubAgentOptions {
+  model: string;
+  baseURL?: string;
+  apiKey: string;
+  timeout?: number;
+}
+
+// ─── Defaults ──────────────────────────────────────────────────────
+
+const DEFAULT_TIMEOUT = 180_000; // 3 min – sub-agents need more time
+
+// ─── Model Resolution ──────────────────────────────────────────────
+
+/**
+ * Resolve model config from the store, config-manager, and env-vars.
+ * Falls back through: store → configManager → env → ''
+ *
+ * This is the single source of truth used by every multi-agent command.
+ */
+export function resolveModelConfig(): ResolvedModelConfig {
+  // Try store first
+  let model: string | undefined;
+  let baseURL: string | undefined;
+  let apiKey: string | undefined;
+
+  try {
+    // Dynamic import to avoid circular deps at module level
+    const store = require('../../store/index.js');
+    const currentModel = store.getCurrentModel();
+    if (currentModel) {
+      model  = (currentModel as any).model || (currentModel as any).id;
+      baseURL = (currentModel as any).baseURL || (currentModel as any).baseUrl;
+      apiKey  = (currentModel as any).apiKey;
+    }
+  } catch { /* store not ready */ }
+
+  // Fallback: configManager
+  if (!apiKey) {
+    try {
+      const def = configManager.getDefaultModel() as any;
+      if (def) {
+        model   = model   || def.model || def.id;
+        baseURL = baseURL || def.baseURL || def.baseUrl;
+        apiKey  = apiKey  || def.apiKey;
+      }
+    } catch { /* config not ready */ }
+  }
+
+  // Fallback: env vars
+  model   = model   || process.env.OPENAI_MODEL || '';
+  baseURL = baseURL || process.env.OPENAI_BASE_URL || '';
+  apiKey  = apiKey  || resolveApiKeyFromEnv(baseURL || '');
+
+  return { model: model || '', baseURL: baseURL || undefined, apiKey: apiKey || '', timeout: DEFAULT_TIMEOUT };
+}
+
+/**
+ * Pick the matching API key from env based on base URL.
+ */
+export function resolveApiKeyFromEnv(baseURL: string): string {
+  const bu = baseURL.toLowerCase();
+  if (bu.includes('anthropic'))    return process.env.ANTHROPIC_API_KEY || '';
+  if (bu.includes('deepseek'))     return process.env.DEEPSEEK_API_KEY || '';
+  if (bu.includes('groq'))         return process.env.GROQ_API_KEY || '';
+  if (bu.includes('openai'))       return process.env.OPENAI_API_KEY || '';
+  // Wildcard fallback
+  return process.env.DEEPSEEK_API_KEY
+    || process.env.OPENAI_API_KEY
+    || process.env.GROQ_API_KEY
+    || process.env.ANTHROPIC_API_KEY
+    || '';
+}
+
+/**
+ * Build a safe ModelConfig object (throws if apiKey is missing).
+ */
+export function requireModelConfig(): ResolvedModelConfig {
+  const cfg = resolveModelConfig();
+  if (!cfg.apiKey) {
+    throw new Error(
+      'No API key configured. Set DEEPSEEK_API_KEY, OPENAI_API_KEY, ' +
+      'GROQ_API_KEY, or ANTHROPIC_API_KEY in ~/.aegiscode/.env'
+    );
+  }
+  return cfg;
+}
+
+// ─── Tool Setup Helpers ────────────────────────────────────────────
+
+/**
+ * Create a lightweight tool registry + execution pipeline for sub-agents.
+ *
+ * When `allowAllBuiltins` is true the agent gets Read/Edit/Write/Grep/Glob/Bash.
+ * Otherwise you can pass a list of tool names.
+ */
+export function createSubAgentToolkit(allowedTools?: string[], options?: { permissionMode?: PermissionMode }) {
+  const registry = createToolRegistry();
+  const builtins = getBuiltinTools();
+
+  const names = allowedTools || ['Read', 'Grep', 'Glob', 'Edit', 'Write', 'Bash'];
+  for (const tool of builtins) {
+    if (names.includes(tool.name)) {
+      registry.register(tool);
+    }
+  }
+
+  const mode = options?.permissionMode || resolveDefaultPermissionMode();
+  const pipeline = new ExecutionPipeline(registry, {
+    defaultMode: mode,
+  });
+
+  return { registry, pipeline };
+}
+
+/**
+ * Read the user's configured permission mode, falling back to DEFAULT (ask for confirmation).
+ */
+function resolveDefaultPermissionMode(): PermissionMode {
+  try {
+    const mode = configManager.getDefaultPermissionMode();
+    switch (mode) {
+      case 'autoEdit': return PermissionMode.AUTO_EDIT;
+      case 'yolo':     return PermissionMode.YOLO;
+      case 'plan':     return PermissionMode.PLAN;
+      default:         return PermissionMode.DEFAULT;
+    }
+  } catch {
+    return PermissionMode.DEFAULT;
+  }
+}
+
+/**
+ * Make a lightweight chat service from a resolved model config.
+ */
+export function createSubAgentChatService(cfg: ResolvedModelConfig) {
+  return createChatService({
+    apiKey: cfg.apiKey,
+    baseURL: cfg.baseURL,
+    model: cfg.model,
+    timeout: cfg.timeout,
+  });
+}
+
+// ─── Workspace Source Context ─────────────────────────────────────
+
+const IGNORE_DIRS = new Set([
+  'node_modules', '.git', 'dist', 'build', '.next', '.turbo',
+  'coverage', '.nyc_output', '__pycache__', '.cache', 'target',
+  'vendor', '.venv', 'venv', '.aegiscode', '.claude',
+]);
+
+const SOURCE_EXTENSIONS = new Set([
+  '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+  '.py', '.rs', '.go', '.java', '.rb', '.php',
+  '.vue', '.svelte', '.css', '.scss', '.html',
+  '.json', '.yaml', '.yml', '.toml', '.prisma',
+]);
+
+// Config files that are always included (even if they'd exceed maxFiles)
+const ALWAYS_INCLUDE = new Set([
+  'package.json', 'tsconfig.json', 'tsconfig.tsbuildinfo',
+  '.env.example', 'docker-compose.yml', 'Dockerfile',
+  'Makefile', 'Cargo.toml', 'go.mod', 'Gemfile',
+  'requirements.txt', 'Pipfile', 'pyproject.toml',
+  'wrangler.jsonc', 'wrangler.toml', '.eslintrc.js', '.prettierrc',
+]);
+
+/** Extract structural summary (exports / classes / functions / interfaces) from source */
+function extractStructure(content: string): string {
+  const lines = content.split('\n');
+  const sigs: string[] = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    // Exports
+    if (/^export\s+(default\s+)?(function|class|interface|type|enum|const|let|var|async\s+function)/.test(trimmed)) {
+      sigs.push(trimmed.replace(/^export\s+default\s+/, 'export default ').replace(/^export\s+/, ''));
+    }
+    // Top-level function/class defs (non-exported)
+    else if (/^(function|class|interface|type|enum|async\s+function)\s+\w+/.test(trimmed)) {
+      sigs.push(trimmed);
+    }
+    // Module-level const/let that looks like a binding (e.g., "const foo = ...")
+    else if (/^(const|let|var)\s+\w+\s*[:=]/.test(trimmed) && !trimmed.includes(';') && !trimmed.endsWith(')')) {
+      const name = trimmed.match(/^(const|let|var)\s+(\w+)/);
+      if (name) sigs.push(`${name[1]} ${name[2]} = ...`);
+    }
+    if (sigs.length >= 30) break;
+  }
+  return sigs.join('\n');
+}
+
+/** Try to load a JSON config file and return pretty-printed key fields */
+function loadConfigSummary(cwd: string, name: string): string | null {
+  try {
+    const raw = fs.readFileSync(path.join(cwd, name), 'utf8');
+    const parsed = JSON.parse(raw) as Record<string, unknown>;
+    if (name === 'package.json') {
+      const deps = parsed.dependencies as Record<string, string> | undefined;
+      const devDeps = parsed.devDependencies as Record<string, string> | undefined;
+      const scripts = parsed.scripts as Record<string, string> | undefined;
+      const entries = [`name: ${parsed.name || '(unnamed)'}`];
+      if (parsed.type) entries.push(`type: ${parsed.type}`);
+      if (scripts) entries.push(`scripts: ${Object.keys(scripts).join(', ')}`);
+      if (deps) entries.push(`deps[${Object.keys(deps).length}]: ${Object.keys(deps).slice(0, 20).join(', ')}`);
+      if (devDeps) entries.push(`devDeps[${Object.keys(devDeps).length}]: ${Object.keys(devDeps).slice(0, 15).join(', ')}`);
+      return entries.join('\n');
+    }
+    if (name === 'tsconfig.json') {
+      const compiler = (parsed.compilerOptions as Record<string, unknown>) || {};
+      const entries: string[] = [];
+      if (compiler.target) entries.push(`target: ${compiler.target}`);
+      if (compiler.module) entries.push(`module: ${compiler.module}`);
+      if (compiler.outDir) entries.push(`outDir: ${compiler.outDir}`);
+      if (compiler.rootDir) entries.push(`rootDir: ${compiler.rootDir}`);
+      if (compiler.paths) entries.push(`paths: ${JSON.stringify(compiler.paths)}`);
+      return entries.length ? entries.join('\n') : null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/** Get list of recently changed files from git (last N commits) */
+function getRecentGitChanges(cwd: string, max = 10): string[] {
+  try {
+    const out = execSync('git diff --name-only HEAD~5..HEAD 2>/dev/null || git diff --name-only HEAD~3..HEAD 2>/dev/null || true', {
+      cwd,
+      encoding: 'utf8',
+      timeout: 2000,
+    });
+    const files = out.split('\n').filter(Boolean).slice(0, max);
+    // Only keep source files that actually exist
+    return files.filter(f => {
+      const ext = path.extname(f).toLowerCase();
+      return SOURCE_EXTENSIONS.has(ext) && fs.existsSync(path.join(cwd, f));
+    });
+  } catch {
+    return [];
+  }
+}
+
+/** Sort source files: recently modified first, then alphabetical */
+function prioritizeFiles(files: string[], cwd: string, recentGit: string[]): string[] {
+  const recentSet = new Set(recentGit.map(f => path.resolve(cwd, f)));
+  const isConfig = (f: string) => ALWAYS_INCLUDE.has(path.basename(f));
+
+  return [...files].sort((a, b) => {
+    // Config files always first
+    if (isConfig(a) && !isConfig(b)) return -1;
+    if (!isConfig(a) && isConfig(b)) return 1;
+    // Recently git-changed files next
+    const aRecent = recentSet.has(a) ? 1 : 0;
+    const bRecent = recentSet.has(b) ? 1 : 0;
+    if (aRecent !== bRecent) return bRecent - aRecent;
+    // Then by modification time (newest first)
+    try {
+      return fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs;
+    } catch {
+      return a.localeCompare(b);
+    }
+  });
+}
+
+/**
+ * Build a rich source-code context string for a workspace directory.
+ *
+ * Scans the workspace and provides:
+ * - Project metadata (package.json scripts/deps, tsconfig)
+ * - Recently changed files (git)
+ * - Prioritized file tree (configs & recent changes first)
+ * - Structural summaries (exports, classes, functions) for each file
+ *
+ * Injected into sub-agent system prompts so they know what exists
+ * and can target their Read / Grep / Glob calls effectively.
+ */
+export function buildSourceContext(
+  cwd: string,
+  maxFiles = 50,
+  maxTotalChars = 12000,
+): string {
+  try {
+    const lines: string[] = [];
+    let budget = maxTotalChars;
+    const append = (s: string) => {
+      if (s.length + 2 <= budget) {
+        lines.push(s);
+        budget -= s.length + 1;
+      }
+    };
+
+    // ── Project Metadata ──
+    const pkg = loadConfigSummary(cwd, 'package.json');
+    const tsConfig = loadConfigSummary(cwd, 'tsconfig.json');
+    if (pkg || tsConfig) {
+      append('--- PROJECT ---');
+      if (pkg) append(pkg);
+      if (tsConfig) append(tsConfig);
+      append('');
+    }
+
+    // ── Git Context ──
+    const recentGit = getRecentGitChanges(cwd);
+    if (recentGit.length > 0) {
+      append('--- RECENTLY CHANGED (git) ---');
+      for (const f of recentGit) append(`  ${f}`);
+      append('');
+    }
+
+    // ── File scan + prioritization ──
+    const allFiles = listSourceFiles(cwd, maxFiles);
+    if (allFiles.length === 0) return lines.join('\n').trim();
+
+    const prioritized = prioritizeFiles(allFiles, cwd, recentGit);
+
+    append('--- SOURCE FILES ---');
+    append(`Directory: ${cwd}`);
+    append('');
+    for (const f of prioritized) {
+      const display = path.relative(cwd, f);
+      if (budget <= 50) { append(`  ... and ${allFiles.length - prioritized.indexOf(f)} more files`); break; }
+      append(`  ${display}`);
+    }
+    append('');
+
+    // ── Structural summaries for top files ──
+    const summaryCount = Math.min(prioritized.length, 15);
+    for (let i = 0; i < summaryCount && budget > 300; i++) {
+      const f = prioritized[i];
+      try {
+        const content = fs.readFileSync(f, 'utf8');
+        const rel = path.relative(cwd, f);
+        const structure = extractStructure(content);
+        if (structure) {
+          const header = `--- ${rel} ---`;
+          const block = `\n${header}\n${structure}\n`;
+          if (block.length < budget - 100) {
+            append(block);
+          }
+        }
+      } catch { /* skip unreadable */ }
+    }
+
+    // ── Footer ──
+    const footer = '--- END WORKSPACE SOURCE ---';
+    if (footer.length <= budget) append(footer);
+
+    return lines.join('\n');
+  } catch {
+    return '';
+  }
+}
+
+function listSourceFiles(dir: string, max: number): string[] {
+  const result: string[] = [];
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const e of entries) {
+      if (result.length >= max) break;
+      if (e.name.startsWith('.') || IGNORE_DIRS.has(e.name)) continue;
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        result.push(...listSourceFiles(full, max - result.length));
+      } else if (e.isFile()) {
+        const ext = path.extname(e.name).toLowerCase();
+        if (SOURCE_EXTENSIONS.has(ext)) {
+          result.push(full);
+        }
+      }
+    }
+  } catch { /* skip inaccessible */ }
+  return result;
+}

package/src/agent/pricing.ts

@@ -0,0 +1,115 @@
+/**
+ * Pricing database — per-model costs in $/1M tokens (input, output).
+ *
+ * These are the raw provider costs before the AEGIS margin is applied.
+ * Auto-router uses cheapest-first ordering; billing uses actual token
+ * counts from each API call to compute the dollar cost and the 3× margin.
+ */
+export type ModelCost = { input: number; output: number };
+
+/**
+ * Price table keyed by model-id (the id field in config/models[]).
+ * Falls back to partial name matching, then to a sensible default.
+ */
+const MODEL_COST_TABLE: Record<string, ModelCost> = {
+  // ── Anthropic ──
+  'claude-opus-4':      { input: 15,   output: 75   },
+  'claude-sonnet-4':    { input: 3,    output: 15   },
+  'claude-haiku-4':     { input: 0.8,  output: 4    },
+  'claude-fable-5':     { input: 5,    output: 25   },
+
+  // ── OpenAI ──
+  'openai-gpt-4o':      { input: 2.5,  output: 10   },
+  'openai-o3':          { input: 10,   output: 40   },
+  'openai-gpt-5.5':     { input: 10,   output: 40   },
+  'chatgpt':            { input: 2.5,  output: 10   },
+
+  // ── DeepSeek ──
+  'deepseek-chat':      { input: 0.14, output: 0.28 },
+  'deepseek-reasoner':  { input: 0.55, output: 2.19 },
+
+  // ── Groq ──
+  'groq-llama':         { input: 0.06, output: 0.06 },
+  'groq-deepseek':      { input: 0.06, output: 0.06 },
+
+  // ── Google ──
+  'gemini-2.5-pro':     { input: 1.25, output: 10   },
+  'gemini-2.5-flash':   { input: 0.15, output: 0.60 },
+
+  // ── Local ──
+  'ollama-local':       { input: 0,    output: 0    },
+};
+
+/**
+ * Look up a model's raw provider cost by its model-id.
+ * Falls back to partial name matching when no exact key exists.
+ * Returns a sensible default ($1/$3 per MTok) when unknown.
+ */
+export function costForModel(modelIdOrName: string): ModelCost {
+  const exact = MODEL_COST_TABLE[modelIdOrName];
+  if (exact) return exact;
+
+  const key = modelIdOrName.toLowerCase();
+  for (const [id, cost] of Object.entries(MODEL_COST_TABLE)) {
+    if (key.includes(id) || id.includes(key)) return cost;
+  }
+  return { input: 1, output: 3 }; // fallback
+}
+
+/**
+ * Compute the raw dollar cost for a single API call.
+ *
+ * @param modelId  Model identifier (used for price lookup)
+ * @param promptTokens  Tokens in the prompt/input
+ * @param completionTokens  Tokens in the completion/output
+ * @returns  Raw provider cost in dollars
+ */
+export function computeRawCost(
+  modelId: string,
+  promptTokens: number,
+  completionTokens: number,
+): number {
+  const { input, output } = costForModel(modelId);
+  return (promptTokens * input + completionTokens * output) / 1_000_000;
+}
+
+/** Margin multiplier applied to raw provider cost. */
+export const MARGIN_MULTIPLIER = 3;
+
+/**
+ * Compute the billed (user-facing) cost including the AEGIS margin.
+ * Billed cost = raw cost × MARGIN_MULTIPLIER.
+ * The difference (billed − raw) is the AEGIS margin.
+ */
+export function computeBilledCost(rawCost: number): number {
+  return rawCost * MARGIN_MULTIPLIER;
+}
+
+/**
+ * Convenience — returns both raw and billed cost in one call.
+ *
+ * @returns  { rawCost, billedCost, marginAmount }
+ */
+export function computeCosts(
+  modelId: string,
+  promptTokens: number,
+  completionTokens: number,
+): { rawCost: number; billedCost: number; marginAmount: number } {
+  const rawCost = computeRawCost(modelId, promptTokens, completionTokens);
+  const billedCost = computeBilledCost(rawCost);
+  return {
+    rawCost,
+    billedCost,
+    marginAmount: billedCost - rawCost,
+  };
+}
+
+/** Format a dollar value to a readable string (short, no trailing zeros). */
+export function formatCost(usd: number): string {
+  if (usd === 0) return '$0';
+  if (usd < 0.00001) return '<$0.00001';
+  if (usd < 0.01) return `$${usd.toFixed(5)}`;
+  if (usd < 1) return `$${usd.toFixed(4)}`;
+  if (usd < 100) return `$${usd.toFixed(3)}`;
+  return `$${usd.toFixed(2)}`;
+}

package/src/agent/router.ts

@@ -0,0 +1,74 @@
+/**
+ * Auto-router — classifies a task's complexity with cheap heuristics (no LLM
+ * call) and resolves which configured model should handle it, so a quick
+ * lookup doesn't pay for an expensive model and a hard refactor doesn't get
+ * shortchanged by a weak one.
+ */
+
+import type { ModelConfig } from '../config/types.js';
+import { pickByOutcomes } from './routerStats.js';
+
+export type ComplexityTier = 'simple' | 'medium' | 'complex';
+
+const COMPLEX_KEYWORDS = [
+  'architecture', 'refactor', 'security', 'design', 'rewrite', 'migrate',
+  'migration', 'performance', 'race condition', 'concurrency', 'scalability',
+  'vulnerability', 'audit', 'distributed', 'consensus', 'deadlock',
+];
+
+const SIMPLE_LEAD_WORDS = new Set([
+  'what', 'why', 'how', 'when', 'where', 'who', 'is', 'are', 'does', 'do',
+  'can', 'explain', 'list', 'show', 'define',
+]);
+
+/** Cheap heuristics, no LLM call — classify before picking a model. */
+export function classifyComplexity(message: string): ComplexityTier {
+  const text = message.trim();
+  const lower = text.toLowerCase();
+  const wordCount = text.split(/\s+/).filter(Boolean).length;
+
+  if (COMPLEX_KEYWORDS.some(kw => lower.includes(kw)) || wordCount > 80) {
+    return 'complex';
+  }
+
+  const firstWord = lower.split(/\s+/)[0]?.replace(/[^a-z]/g, '') || '';
+  const looksLikeQuestion = SIMPLE_LEAD_WORDS.has(firstWord) || text.endsWith('?');
+  const mentionsManyFiles =
+    (text.match(/\b[\w./-]+\.(ts|tsx|js|jsx|py|go|rs|java|json|md)\b/gi) || []).length > 2;
+
+  if (looksLikeQuestion && wordCount <= 25 && !mentionsManyFiles) {
+    return 'simple';
+  }
+
+  return 'medium';
+}
+
+/** Cheapest → strongest known model ids per tier, used when no explicit tier is set. */
+const TIER_FALLBACKS: Record<ComplexityTier, string[]> = {
+  simple:  ['groq-llama', 'deepseek-chat', 'claude-haiku-4', 'gemini-2.5-flash', 'chatgpt'],
+  medium:  ['deepseek-chat', 'claude-sonnet-4', 'gemini-2.5-pro', 'openai-gpt-4o', 'chatgpt'],
+  complex: ['claude-opus-4', 'openai-o3', 'claude-sonnet-4', 'gemini-2.5-pro', 'chatgpt'],
+};
+
+/**
+ * Resolve which configured model should handle this tier. Prefers an
+ * explicit tier->modelId mapping; falls back to the first usable
+ * (non-empty apiKey) model from a fixed cost-ordered list. Returns
+ * undefined if nothing usable is found — caller should keep using
+ * whatever model is already active.
+ */
+export function resolveModelForTier(
+  tier: ComplexityTier,
+  models: ModelConfig[],
+  explicitTiers?: Partial<Record<ComplexityTier, string>>,
+): ModelConfig | undefined {
+  const usable = (id?: string): ModelConfig | undefined =>
+    id ? models.find(m => m.id === id && m.apiKey) : undefined;
+
+  const explicit = usable(explicitTiers?.[tier]);
+  if (explicit) return explicit;
+
+  const usableIds = TIER_FALLBACKS[tier].filter(id => usable(id));
+  const picked = pickByOutcomes(tier, usableIds);
+  return usable(picked);
+}