aegiscode 3.1.10 → 3.4.2

package/src/agent/orchestrator/utils.ts

@@ -1,397 +0,0 @@
-/**
- * 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

@@ -1,115 +0,0 @@
-/**
- * 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

@@ -1,74 +0,0 @@
-/**
- * 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);
-}