@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-OJBH62DK.js

@@ -0,0 +1,684 @@
+import {
+  analyzeTask,
+  canonicalizeDirectivePath
+} from "./chunk-EKLUBDBQ.js";
+import {
+  evaluateComplexity,
+  scoreToLevel
+} from "./chunk-NEQUQHOX.js";
+import {
+  detectTaskType
+} from "./chunk-UKMPASIC.js";
+import {
+  withTimeout
+} from "./chunk-5F43TUIN.js";
+import {
+  isProjectTestPath
+} from "./chunk-RPIMAMV7.js";
+import {
+  findProjectRoot
+} from "./chunk-35J4NE6S.js";
+import {
+  isRuntimeEnvEnabled
+} from "./chunk-7VRJHTGZ.js";
+
+// src/orchestrator/agent-registry.ts
+import { promises as fs } from "fs";
+import * as os from "os";
+import * as path from "path";
+var SCORING_WEIGHTS = {
+  keywords: 5,
+  patterns: 10,
+  fileExtensions: 15,
+  taskType: 20
+};
+var SPECIALIZED_AGENT_TASK_TYPES = {
+  database: ["database", "sql", "query", "schema", "migration", "postgres", "mysql"],
+  api: ["api", "endpoint", "rest", "graphql", "route", "controller"],
+  frontend: ["ui", "component", "react", "vue", "angular", "css", "style", "layout"],
+  backend: ["backend", "server", "service", "microservice", "api"],
+  devops: ["deploy", "ci", "cd", "pipeline", "docker", "kubernetes", "infrastructure"],
+  ml: ["ml", "machine learning", "model", "training", "dataset", "ai"]
+};
+var AGENT_TASK_TYPE_MAP = {
+  "test-automator": "test",
+  debugger: "debug",
+  "code-reviewer": "review",
+  "architect-reviewer": "review",
+  "security-auditor": "security",
+  "performance-engineer": "performance",
+  "database-admin": "database",
+  "database-optimizer": "database",
+  "sql-pro": "database",
+  "api-documenter": "api",
+  "backend-architect": "backend",
+  "frontend-developer": "frontend",
+  "ui-ux-designer": "frontend",
+  "deployment-engineer": "devops",
+  "devops-troubleshooter": "devops",
+  "cloud-architect": "devops",
+  "kubernetes-architect": "devops",
+  "mlops-engineer": "ml",
+  "ml-engineer": "ml"
+};
+function parseFrontmatter(content) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) {
+    return {};
+  }
+  const frontmatter = {};
+  const lines = frontmatterMatch[1]?.split("\n") || [];
+  for (const line of lines) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    const value = line.slice(colonIndex + 1).trim();
+    frontmatter[key] = value;
+  }
+  return frontmatter;
+}
+function extractKeywords(description) {
+  const keywords = [];
+  const keywordPatterns = [
+    /\b(test|testing|tests)\b/gi,
+    /\b(debug|debugging|fix)\b/gi,
+    /\b(review|audit|analyze)\b/gi,
+    /\b(refactor|optimize|improve)\b/gi,
+    /\b(api|rest|graphql)\b/gi,
+    /\b(database|sql|query)\b/gi,
+    /\b(frontend|ui|component)\b/gi,
+    /\b(backend|server|service)\b/gi,
+    /\b(security|auth|vulnerability)\b/gi,
+    /\b(performance|speed|latency)\b/gi,
+    /\b(typescript|javascript|python|rust|go|java)\b/gi,
+    /\b(react|vue|angular|node)\b/gi,
+    /\b(docker|kubernetes|ci|cd)\b/gi
+  ];
+  for (const pattern of keywordPatterns) {
+    const matches = description.match(pattern);
+    if (matches) {
+      keywords.push(...matches.map((m) => m.toLowerCase()));
+    }
+  }
+  return Array.from(new Set(keywords));
+}
+function extractPatterns(description) {
+  const patterns = [];
+  const actionPatterns = [
+    /\b(create|build|implement|develop|generate)\b/gi,
+    /\b(optimize|improve|enhance|refactor)\b/gi,
+    /\b(debug|fix|resolve|troubleshoot)\b/gi,
+    /\b(review|analyze|audit|inspect)\b/gi,
+    /\b(design|architect|plan)\b/gi,
+    /\b(test|validate|verify)\b/gi,
+    /\b(document|write|explain)\b/gi
+  ];
+  for (const pattern of actionPatterns) {
+    const matches = description.match(pattern);
+    if (matches) {
+      patterns.push(...matches.map((m) => m.toLowerCase()));
+    }
+  }
+  return Array.from(new Set(patterns));
+}
+function extractFileExtensions(description) {
+  const extensions = [];
+  const extensionMap = {
+    typescript: [".ts", ".tsx"],
+    javascript: [".js", ".jsx", ".mjs"],
+    python: [".py"],
+    rust: [".rs"],
+    go: [".go"],
+    java: [".java"],
+    csharp: [".cs"],
+    cpp: [".cpp", ".cc", ".cxx", ".hpp"],
+    c: [".c", ".h"],
+    ruby: [".rb"],
+    php: [".php"],
+    scala: [".scala"],
+    elixir: [".ex", ".exs"],
+    flutter: [".dart"]
+  };
+  const lowerDesc = description.toLowerCase();
+  for (const [lang, exts] of Object.entries(extensionMap)) {
+    const wordPattern = new RegExp(`\\b${lang}\\b`);
+    if (wordPattern.test(lowerDesc)) {
+      extensions.push(...exts);
+    }
+  }
+  return Array.from(new Set(extensions));
+}
+async function loadAgentDefinition(filePath) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    const frontmatter = parseFrontmatter(content);
+    if (!frontmatter.name || !frontmatter.description) {
+      return null;
+    }
+    return {
+      name: frontmatter.name,
+      description: frontmatter.description,
+      keywords: extractKeywords(frontmatter.description),
+      patterns: extractPatterns(frontmatter.description),
+      fileExtensions: extractFileExtensions(frontmatter.description)
+    };
+  } catch (error) {
+    console.warn(`Failed to load agent from ${filePath}:`, error);
+    return null;
+  }
+}
+async function loadAgentsFromDirectory(directory) {
+  try {
+    const files = await fs.readdir(directory);
+    const agentFiles = files.filter((f) => f.endsWith(".md"));
+    const agents = await Promise.all(
+      agentFiles.map((file) => loadAgentDefinition(path.join(directory, file)))
+    );
+    return agents.filter((agent) => agent !== null);
+  } catch {
+    return [];
+  }
+}
+var CANONICAL_TO_AGENT_TASK_TYPE = {
+  test: "test",
+  bug_fix: "debug",
+  review: "review",
+  refactor: "refactor",
+  documentation: "document",
+  security: "security",
+  performance: "performance",
+  analysis: "review",
+  feature: null,
+  migration: "database",
+  maintenance: null,
+  general: null
+};
+var EXPLICIT_AGENT_ROUTING_OVERRIDES = [
+  {
+    taskType: "debug",
+    patterns: [
+      /\b(fix|debug|resolve|troubleshoot)\b/i,
+      /\b(error|bug|issue|fail(?:ing|ure)?|crash|exception|regression)\b/i
+    ]
+  },
+  {
+    taskType: "test",
+    patterns: [/\b(test|tests|testing|spec|coverage|unit.?test|integration.?test|e2e)\b/i],
+    negativePatterns: [/fix.*test/i, /test.*fail/i, /broken.*test/i]
+  }
+];
+function detectAgentTaskType(prompt) {
+  const lowerPrompt = prompt.toLowerCase();
+  for (const override of EXPLICIT_AGENT_ROUTING_OVERRIDES) {
+    const hasNegativeMatch = override.negativePatterns?.some((pattern) => pattern.test(lowerPrompt)) ?? false;
+    if (hasNegativeMatch) {
+      continue;
+    }
+    const hasAllPatterns = override.patterns.every((pattern) => pattern.test(lowerPrompt));
+    if (hasAllPatterns) {
+      return override.taskType;
+    }
+  }
+  const canonicalTaskType = detectTaskType(prompt);
+  const canonicalMatch = CANONICAL_TO_AGENT_TASK_TYPE[canonicalTaskType] ?? null;
+  if (canonicalMatch) {
+    return canonicalMatch;
+  }
+  for (const [taskType, keywords] of Object.entries(SPECIALIZED_AGENT_TASK_TYPES)) {
+    for (const keyword of keywords) {
+      if (lowerPrompt.includes(keyword)) {
+        return taskType;
+      }
+    }
+  }
+  return null;
+}
+function scoreAgent(agent, prompt, files) {
+  const lowerPrompt = prompt.toLowerCase();
+  let keywordScore = 0;
+  let patternScore = 0;
+  let fileExtensionScore = 0;
+  let taskTypeScore = 0;
+  for (const keyword of agent.keywords) {
+    if (lowerPrompt.includes(keyword)) {
+      keywordScore += SCORING_WEIGHTS.keywords;
+    }
+  }
+  for (const pattern of agent.patterns) {
+    if (lowerPrompt.includes(pattern)) {
+      patternScore += SCORING_WEIGHTS.patterns;
+    }
+  }
+  if (files && files.length > 0) {
+    for (const file of files) {
+      const ext = path.extname(file);
+      if (agent.fileExtensions.includes(ext)) {
+        fileExtensionScore += SCORING_WEIGHTS.fileExtensions;
+      }
+    }
+  }
+  const taskType = detectAgentTaskType(prompt);
+  if (taskType && AGENT_TASK_TYPE_MAP[agent.name] === taskType) {
+    taskTypeScore = SCORING_WEIGHTS.taskType;
+  }
+  const totalScore = keywordScore + patternScore + fileExtensionScore + taskTypeScore;
+  return {
+    agent,
+    score: totalScore,
+    breakdown: {
+      keywords: keywordScore,
+      patterns: patternScore,
+      fileExtensions: fileExtensionScore,
+      taskType: taskTypeScore
+    }
+  };
+}
+var AgentRegistry = class {
+  agents = [];
+  initialized = false;
+  /**
+   * Get agent directories in priority order
+   * Project definitions override Build-global and Claude-compatible definitions.
+   */
+  getAgentDirectories() {
+    const homeDir = os.homedir();
+    const projectRoot = findProjectRoot(process.cwd()) ?? process.cwd();
+    return [
+      path.join(projectRoot, ".build-project", "agents"),
+      path.join(homeDir, ".build", "agents"),
+      path.join(homeDir, ".claude", "agents")
+    ];
+  }
+  /**
+   * Load all agents from available directories
+   */
+  async loadAgents() {
+    const directories = this.getAgentDirectories();
+    const allAgents = [];
+    for (const dir of directories) {
+      const agents = await loadAgentsFromDirectory(dir);
+      allAgents.push(...agents);
+    }
+    const uniqueAgents = /* @__PURE__ */ new Map();
+    for (const agent of allAgents) {
+      if (!uniqueAgents.has(agent.name)) {
+        uniqueAgents.set(agent.name, agent);
+      }
+    }
+    this.agents = Array.from(uniqueAgents.values());
+    this.initialized = true;
+  }
+  /**
+   * Ensure agents are loaded
+   */
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.loadAgents();
+    }
+  }
+  /**
+   * Find the best agent for a given task
+   */
+  async findBestAgent(prompt, files) {
+    await this.ensureInitialized();
+    if (this.agents.length === 0) {
+      throw new Error(
+        "No agents available. Add definitions under .build-project/agents/, ~/.build/agents/, or ~/.claude/agents/."
+      );
+    }
+    const scores = this.agents.map((agent) => scoreAgent(agent, prompt, files));
+    scores.sort((a, b) => b.score - a.score);
+    const bestScore = scores[0];
+    if (!bestScore) {
+      throw new Error("No agents available");
+    }
+    if (bestScore.score === 0) {
+      const generalPurpose = this.agents.find((a) => a.name === "general-purpose");
+      if (generalPurpose) {
+        return generalPurpose;
+      }
+      const fallbackAgent = scores[0]?.agent ?? this.agents[0];
+      if (!fallbackAgent) {
+        throw new Error("No agents available for selection");
+      }
+      return fallbackAgent;
+    }
+    const selectedAgent = bestScore?.agent ?? this.agents[0];
+    if (!selectedAgent) {
+      throw new Error("No agents available for selection");
+    }
+    return selectedAgent;
+  }
+  /**
+   * Get agent by name
+   */
+  async getAgent(name) {
+    await this.ensureInitialized();
+    return this.agents.find((a) => a.name === name);
+  }
+  /**
+   * Get all available agents
+   */
+  async getAllAgents() {
+    await this.ensureInitialized();
+    return [...this.agents];
+  }
+  /**
+   * Explain agent selection for debugging
+   */
+  async explainAgentSelection(prompt, files) {
+    await this.ensureInitialized();
+    if (this.agents.length === 0) {
+      throw new Error("No agents available");
+    }
+    const scores = this.agents.map((agent) => scoreAgent(agent, prompt, files));
+    scores.sort((a, b) => b.score - a.score);
+    const fallbackScore = this.agents[0] ? {
+      agent: this.agents[0],
+      score: 0,
+      breakdown: {
+        keywords: 0,
+        patterns: 0,
+        fileExtensions: 0,
+        taskType: 0
+      }
+    } : null;
+    return {
+      selected: scores[0] ?? fallbackScore ?? (this.agents[0] ? {
+        agent: this.agents[0],
+        score: 0,
+        breakdown: {
+          keywords: 0,
+          patterns: 0,
+          fileExtensions: 0,
+          taskType: 0
+        }
+      } : {
+        agent: {
+          name: "unknown",
+          description: "No agent available",
+          keywords: [],
+          patterns: [],
+          fileExtensions: []
+        },
+        score: 0,
+        breakdown: {
+          keywords: 0,
+          patterns: 0,
+          fileExtensions: 0,
+          taskType: 0
+        }
+      }),
+      alternatives: scores.slice(1, 6)
+      // Top 5 alternatives
+    };
+  }
+};
+var agentRegistry = new AgentRegistry();
+
+// src/orchestrator/domain-analyzer.ts
+var FILE_DIRECTIVE_PATTERN = /^[ \t]*FILE:[ \t]*([^\s]+)/gim;
+var DOMAIN_KEYWORD_MAP = {
+  frontend: [
+    "ui",
+    "user interface",
+    "component",
+    "css",
+    "scss",
+    "tailwind",
+    "react",
+    "next.js",
+    "responsive",
+    "accessibility",
+    "design system"
+  ],
+  backend: [
+    "api",
+    "service",
+    "server",
+    "handler",
+    "database",
+    "persistence",
+    "auth",
+    "queue",
+    "worker",
+    "controller",
+    "endpoint"
+  ],
+  testing: ["test", "testing", "unit test", "integration test", "coverage", "regression"],
+  docs: ["docs", "documentation", "readme", "guide", "changelog", "write-up"],
+  infra: [
+    "infrastructure",
+    "deploy",
+    "pipeline",
+    "ci",
+    "terraform",
+    "docker",
+    "kubernetes",
+    "helm",
+    "config"
+  ],
+  data: ["analytics", "metrics", "sql", "warehouse", "etl", "report", "data pipeline"],
+  general: []
+};
+var DOMAIN_FILE_HINTS = {
+  frontend: [
+    /(?:component|pages?|ui|client|styles?)\//i,
+    /\.(?:tsx|jsx|css|scss|sass|less|html)$/i
+  ],
+  backend: [
+    /(?:server|api|services?|controllers?|lib|src\/core)\//i,
+    /\.(?:ts|js|py|rb|go|java|rs)$/i
+  ],
+  // Polyglot test files are now also scored via isProjectTestPath in scoreDomain.
+  // These regexes remain as lightweight path/dir hints.
+  testing: [/(?:__tests__|tests?|specs?)\//i, /\.(?:test|spec)\./i],
+  docs: [/(?:docs?|guides?|handbook)\//i, /\.(?:md|mdx)$/i],
+  infra: [
+    /(?:infra|ops|deploy|scripts?|config|helm|charts?)\//i,
+    /\.(?:ya?ml|json|tf|dockerfile|sh)$/i
+  ],
+  data: [/(?:analytics|data|warehouse|sql)\//i, /\.(?:sql|ipynb|parquet)$/i],
+  general: []
+};
+var DOMAIN_FEATURE_HINTS = {
+  frontend: [/ui/i, /component/i, /accessibility/i, /layout/i],
+  backend: [/api/i, /service/i, /performance/i, /refactor/i],
+  testing: [/test/i, /assert/i, /coverage/i],
+  docs: [/document/i, /guide/i, /explain/i],
+  infra: [/deploy/i, /pipeline/i, /config/i, /infrastructure/i],
+  data: [/data/i, /metrics/i, /analytics/i, /report/i],
+  general: []
+};
+function normalizeUnique(values) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) continue;
+    seen.add(trimmed);
+  }
+  return Array.from(seen);
+}
+function extractFileDirectives(prompt) {
+  const files = [];
+  for (const match of prompt.matchAll(FILE_DIRECTIVE_PATTERN)) {
+    const candidate = match[1]?.trim();
+    if (!candidate) continue;
+    const canonical = canonicalizeDirectivePath(candidate);
+    if (canonical) files.push(canonical);
+  }
+  return files;
+}
+function mapComplexityLevel(level) {
+  switch (level) {
+    case "trivial":
+    case "simple":
+      return "low";
+    case "moderate":
+      return "medium";
+    case "complex":
+      return "high";
+  }
+}
+function computeComplexityScore(prompt) {
+  const evaluation = evaluateComplexity(prompt);
+  const level = scoreToLevel(evaluation.complexityScore);
+  return mapComplexityLevel(level);
+}
+function scoreDomain(prompt, files, features) {
+  const lowerPrompt = prompt.toLowerCase();
+  const scores = {};
+  const heuristics = [];
+  const allDomains = ["frontend", "backend", "testing", "docs", "infra", "data"];
+  const KEYWORD_WEIGHT = 2;
+  const FEATURE_WEIGHT = 1.5;
+  const FILE_HINT_WEIGHT = 1.5;
+  const GENERIC_FILE_HINT_WEIGHT = 0.75;
+  for (const domain of allDomains) {
+    scores[domain] = 0;
+    for (const keyword of DOMAIN_KEYWORD_MAP[domain]) {
+      if (lowerPrompt.includes(keyword)) {
+        scores[domain] = (scores[domain] ?? 0) + KEYWORD_WEIGHT;
+        heuristics.push(`Prompt keyword "${keyword}" \u2192 ${domain}`);
+      }
+    }
+    for (const regex of DOMAIN_FEATURE_HINTS[domain]) {
+      if (features.some((feature) => regex.test(feature))) {
+        scores[domain] = (scores[domain] ?? 0) + FEATURE_WEIGHT;
+        heuristics.push(`Feature hint ${regex} \u2192 ${domain}`);
+      }
+    }
+    for (const file of files) {
+      if (domain === "testing" && isProjectTestPath(file)) {
+        scores[domain] = (scores[domain] ?? 0) + FILE_HINT_WEIGHT;
+        heuristics.push(`File hint "${file}" matched isProjectTestPath \u2192 ${domain}`);
+        continue;
+      }
+      for (const regex of DOMAIN_FILE_HINTS[domain]) {
+        if (regex.test(file)) {
+          const weight = regex.source.startsWith("\\.") ? GENERIC_FILE_HINT_WEIGHT : FILE_HINT_WEIGHT;
+          scores[domain] = (scores[domain] ?? 0) + weight;
+          heuristics.push(`File hint "${file}" matched ${regex} \u2192 ${domain}`);
+          break;
+        }
+      }
+    }
+  }
+  if (/\btest(s|ing)?\b/.test(lowerPrompt)) {
+    scores.testing = (scores.testing ?? 0) + 1.5;
+    heuristics.push("Global test keyword bonus \u2192 testing");
+  }
+  let bestDomain = "general";
+  let bestScore = 0;
+  for (const domain of allDomains) {
+    const score = scores[domain] ?? 0;
+    if (score > bestScore) {
+      bestScore = score;
+      bestDomain = domain;
+    }
+  }
+  if (bestScore === 0) {
+    scores.general = 1;
+  }
+  return { domain: bestDomain, scores, heuristics };
+}
+var REGISTRY_EXPLAIN_TIMEOUT_MS = 75;
+function useAgentRegistryHints() {
+  return isRuntimeEnvEnabled("BUILD_AGENT_REGISTRY_HINTS");
+}
+var DomainAnalyzer = class {
+  constructor(registry = agentRegistry) {
+    this.registry = registry;
+  }
+  registry;
+  /**
+   * Analyze task prompt for domain classification and routing.
+   *
+   * **Single Source of Truth**: This method consumes TaskAnalysis (from task-analysis.ts)
+   * as the authoritative source for all routing signals. We do NOT re-parse the prompt
+   * or duplicate heuristics here. All routing-relevant fields (compareIntent, speedIntent,
+   * isCritical, filesMentioned, etc.) come from TaskAnalysis.routing.
+   *
+   * This ensures consistency across all routing consumers (AutoOrchestrator, RoutingPlanner).
+   */
+  async analyze(prompt) {
+    const taskAnalysis = analyzeTask(prompt);
+    const routing = taskAnalysis.routing;
+    const filesMentioned = routing.filesMentioned;
+    const fileDirectives = extractFileDirectives(prompt);
+    const requestedFiles = normalizeUnique([...filesMentioned, ...fileDirectives]);
+    const featureList = routing.features;
+    let compareIntent = routing.compareIntent;
+    const speedIntent = routing.speedIntent;
+    const critical = routing.isCritical;
+    const isQuestionAnswer = routing.isQuestionAnswer;
+    const domainScore = scoreDomain(prompt, requestedFiles, featureList);
+    const domain = domainScore.domain;
+    let confidence = 0;
+    let agentConfidence;
+    if (useAgentRegistryHints() || this.registry !== agentRegistry) {
+      try {
+        const explanation = await withTimeout(
+          this.registry.explainAgentSelection(prompt, filesMentioned),
+          REGISTRY_EXPLAIN_TIMEOUT_MS
+        );
+        const bestScore = explanation.selected.score;
+        const secondScore = explanation.alternatives[0]?.score ?? 0;
+        if (bestScore > 0) {
+          agentConfidence = bestScore / (bestScore + (secondScore || bestScore));
+        }
+        const agentName = explanation.selected.agent.name.toLowerCase();
+        if (!compareIntent) {
+          if (explanation.selected.breakdown.taskType > 0 || agentName.includes("review") || agentName.includes("audit") || agentName.includes("judge")) {
+            compareIntent = true;
+          }
+        }
+      } catch {
+      }
+    }
+    let complexity = computeComplexityScore(prompt);
+    if (critical) {
+      complexity = "high";
+    } else if ((compareIntent || requestedFiles.length > 1 || featureList.length > 2) && complexity === "low") {
+      complexity = "medium";
+    }
+    const heuristicTotal = Object.values(domainScore.scores).reduce(
+      (sum, value) => sum + (value ?? 0),
+      0
+    );
+    if (heuristicTotal > 0) {
+      confidence = Math.min(
+        1,
+        (domainScore.scores[domain] ?? 0) / heuristicTotal + (agentConfidence ?? 0) * 0.25
+      );
+    } else if (agentConfidence !== void 0) {
+      confidence = agentConfidence;
+    }
+    if (confidence === 0 && agentConfidence !== void 0) {
+      confidence = Math.min(1, agentConfidence + 0.15);
+    }
+    return {
+      domain,
+      confidence,
+      filesMentioned: normalizeUnique(filesMentioned),
+      requestedFiles,
+      featureCount: featureList.length,
+      compareIntent,
+      speedIntent,
+      complexity,
+      isCritical: critical,
+      isQuestionAnswer,
+      agentConfidence,
+      intent: taskAnalysis.intent,
+      signals: {
+        domainScores: domainScore.scores,
+        heuristicsApplied: domainScore.heuristics
+      }
+    };
+  }
+};
+
+export {
+  DomainAnalyzer
+};
+//# sourceMappingURL=chunk-OJBH62DK.js.map