@triedotdev/mcp 1.0.49 → 1.0.51

package/dist/chunk-C3AS5OXW.js

@@ -0,0 +1,1177 @@
+import {
+  CustomSkill,
+  getGlobalMemoryStats,
+  getHistoricalInsights,
+  getMemoryStats,
+  getRecentIssues,
+  getSkillRegistry,
+  loadContextState
+} from "./chunk-TOE75CFZ.js";
+
+// src/orchestrator/triager.ts
+var Triager = class {
+  agentRegistry = getSkillRegistry();
+  config;
+  customSkillsLoaded = false;
+  contextState = null;
+  memoryInsights = null;
+  constructor(config) {
+    this.config = {
+      minConfidence: 0.15,
+      maxAgents: 11,
+      timeoutMs: 6e4,
+      enableCostAware: false,
+      enableDependencies: true,
+      ...config
+    };
+  }
+  /**
+   * Load previous context state for smart triaging
+   */
+  async loadPreviousContext() {
+    if (this.contextState === null) {
+      try {
+        this.contextState = await loadContextState();
+      } catch {
+        this.contextState = null;
+      }
+    }
+  }
+  /**
+   * Load memory insights for memory-influenced triaging
+   */
+  async loadMemoryInsights() {
+    if (this.memoryInsights !== null) return;
+    try {
+      const [stats, recent, historical, global] = await Promise.all([
+        getMemoryStats().catch(() => null),
+        getRecentIssues({ limit: 20 }).catch(() => []),
+        getHistoricalInsights(process.cwd()).catch(() => null),
+        getGlobalMemoryStats().catch(() => null)
+      ]);
+      const recentAgents = /* @__PURE__ */ new Set();
+      for (const issue of recent) {
+        recentAgents.add(issue.agent);
+      }
+      const recurringPatternAgents = /* @__PURE__ */ new Set();
+      if (historical?.recurringPatterns) {
+        for (const pattern of historical.recurringPatterns) {
+          recurringPatternAgents.add(pattern.agent);
+        }
+      }
+      const crossProjectAgents = /* @__PURE__ */ new Set();
+      if (global?.patternsByAgent) {
+        for (const [agent, count] of Object.entries(global.patternsByAgent)) {
+          if (count >= 2) {
+            crossProjectAgents.add(agent);
+          }
+        }
+      }
+      this.memoryInsights = {
+        issuesByAgent: stats?.issuesByAgent || {},
+        recentAgents,
+        recurringPatternAgents,
+        trend: historical?.improvementTrend || "unknown",
+        crossProjectAgents
+      };
+    } catch {
+      this.memoryInsights = {
+        issuesByAgent: {},
+        recentAgents: /* @__PURE__ */ new Set(),
+        recurringPatternAgents: /* @__PURE__ */ new Set(),
+        trend: "unknown",
+        crossProjectAgents: /* @__PURE__ */ new Set()
+      };
+    }
+  }
+  /**
+   * Ensure custom skills are loaded before triaging
+   */
+  async ensureCustomSkillsLoaded() {
+    if (!this.customSkillsLoaded) {
+      await this.agentRegistry.loadCustomSkills();
+      this.customSkillsLoaded = true;
+    }
+  }
+  async selectAgents(context, riskLevel) {
+    await this.ensureCustomSkillsLoaded();
+    await Promise.all([
+      this.loadPreviousContext(),
+      this.loadMemoryInsights()
+    ]);
+    let effectiveRiskLevel = riskLevel;
+    if (this.contextState?.healthScore !== void 0 && this.contextState.healthScore < 50) {
+      if (riskLevel === "low" || riskLevel === "medium") {
+        effectiveRiskLevel = "high";
+        console.error(`   \u{1F4CA} Health score ${this.contextState.healthScore}% - escalating to ${effectiveRiskLevel.toUpperCase()} risk`);
+      }
+    }
+    if (effectiveRiskLevel === "critical" || effectiveRiskLevel === "high") {
+      console.error(`   \u26A0\uFE0F  ${effectiveRiskLevel.toUpperCase()} risk - activating all agents for comprehensive review`);
+      return this.getAllAgents().filter((agent) => agent.shouldActivate(context));
+    }
+    const scores = this.scoreAgents(context, effectiveRiskLevel);
+    this.boostAgentsWithHistory(scores);
+    this.boostAgentsWithMemory(scores);
+    this.logAgentScoring(scores);
+    const qualified = scores.filter((s) => s.confidence >= this.config.minConfidence);
+    qualified.sort((a, b) => {
+      if (a.tier !== b.tier) return a.tier - b.tier;
+      return b.confidence - a.confidence;
+    });
+    if (this.config.enableDependencies) {
+      return this.resolveDependencies(qualified.map((s) => s.agent));
+    }
+    return qualified.map((s) => s.agent);
+  }
+  /**
+   * Boost confidence for agents that found issues in previous scans
+   */
+  boostAgentsWithHistory(scores) {
+    if (!this.contextState?.agentStatus) return;
+    for (const score of scores) {
+      const previousRun = this.contextState.agentStatus[score.agent.name];
+      if (previousRun?.issuesFound && previousRun.issuesFound > 0) {
+        const boost = Math.min(0.3, previousRun.issuesFound * 0.05);
+        score.confidence = Math.min(1, score.confidence + boost);
+        score.reasons.push(`found ${previousRun.issuesFound} issues in last scan`);
+      }
+    }
+  }
+  /**
+   * Boost confidence for agents based on memory patterns
+   */
+  boostAgentsWithMemory(scores) {
+    if (!this.memoryInsights) return;
+    for (const score of scores) {
+      const agentName = score.agent.name;
+      const historicalCount = this.memoryInsights.issuesByAgent[agentName] || 0;
+      if (historicalCount >= 10) {
+        const boost = Math.min(0.2, historicalCount * 0.01);
+        score.confidence = Math.min(1, score.confidence + boost);
+        score.reasons.push(`${historicalCount} historical issues`);
+      }
+      if (this.memoryInsights.recentAgents.has(agentName)) {
+        score.confidence = Math.min(1, score.confidence + 0.1);
+        score.reasons.push("recent activity");
+      }
+      if (this.memoryInsights.recurringPatternAgents.has(agentName)) {
+        score.confidence = Math.min(1, score.confidence + 0.15);
+        score.reasons.push("recurring patterns");
+      }
+      if (this.memoryInsights.crossProjectAgents.has(agentName)) {
+        score.confidence = Math.min(1, score.confidence + 0.1);
+        score.reasons.push("cross-project pattern");
+      }
+    }
+    if (this.memoryInsights.trend === "declining") {
+      for (const score of scores) {
+        if (score.confidence > 0) {
+          score.confidence = Math.min(1, score.confidence + 0.05);
+        }
+      }
+    }
+  }
+  scoreAgents(context, riskLevel) {
+    const allAgents = this.getAllAgents();
+    const scores = [];
+    for (const agent of allAgents) {
+      const score = this.scoreAgent(agent, context, riskLevel);
+      scores.push(score);
+    }
+    return scores;
+  }
+  scoreAgent(agent, context, riskLevel) {
+    if (agent instanceof CustomSkill) {
+      return this.scoreCustomSkill(agent, context, riskLevel);
+    }
+    return this.scoreBuiltinAgent(agent, context, riskLevel);
+  }
+  /**
+   * Score custom skills using their activation rules
+   */
+  scoreCustomSkill(agent, context, riskLevel) {
+    const reasons = [];
+    let confidence = agent.getActivationConfidence(context);
+    if (confidence > 0) {
+      reasons.push(`custom skill: ${agent.getMetadata().category}`);
+      const meta = agent.getMetadata();
+      if (meta.patternCount > 0) {
+        reasons.push(`${meta.patternCount} detection patterns`);
+      }
+    }
+    if (riskLevel === "high" && confidence > 0) {
+      confidence = Math.min(1, confidence * 1.2);
+    }
+    return {
+      agent,
+      confidence,
+      reasons,
+      tier: agent.priority.tier,
+      isCustom: true
+    };
+  }
+  /**
+   * Score built-in agents
+   */
+  scoreBuiltinAgent(agent, context, riskLevel) {
+    const reasons = [];
+    let confidence = 0;
+    let tier = 3;
+    if (agent.name === "typecheck") {
+      tier = 1;
+      confidence = 1;
+      reasons.push("fundamental type safety");
+    }
+    if (agent.name === "comprehension") {
+      tier = 1;
+      confidence = 1;
+      reasons.push("stakeholder communication");
+    }
+    if (agent.name === "security") {
+      tier = 2;
+      if (context.touchesAuth) {
+        confidence += 0.4;
+        reasons.push("auth code");
+      }
+      if (context.touchesPayments) {
+        confidence += 0.4;
+        reasons.push("payment code");
+      }
+      if (context.touchesAPI) {
+        confidence += 0.3;
+        reasons.push("API endpoints");
+      }
+      if (context.touchesDatabase) {
+        confidence += 0.25;
+        reasons.push("database access");
+      }
+      if (context.touchesCrypto) {
+        confidence += 0.35;
+        reasons.push("cryptographic operations");
+      }
+      if (context.touchesUserData) {
+        confidence += 0.3;
+        reasons.push("user data");
+      }
+      if (context.touchesSecurityConfig) {
+        confidence += 0.4;
+        reasons.push("security config");
+      }
+      if (context.touchesThirdPartyAPI) {
+        confidence += 0.2;
+        reasons.push("third-party integration");
+      }
+      if (context.patterns?.hasFileUploads) {
+        confidence += 0.3;
+        reasons.push("file uploads");
+      }
+      if (riskLevel === "high") confidence *= 1.2;
+    }
+    if (agent.name === "privacy") {
+      tier = 2;
+      if (context.touchesUserData) {
+        confidence += 0.5;
+        reasons.push("PII handling");
+      }
+      if (context.touchesAuth) {
+        confidence += 0.3;
+        reasons.push("credentials");
+      }
+      if (context.touchesLogging) {
+        confidence += 0.25;
+        reasons.push("logging (may expose data)");
+      }
+      if (context.patterns?.hasEmailHandling) {
+        confidence += 0.3;
+        reasons.push("email handling");
+      }
+      if (context.patterns?.hasFormHandling) {
+        confidence += 0.2;
+        reasons.push("form data");
+      }
+    }
+    if (agent.name === "legal") {
+      tier = 2;
+      if (context.touchesUserData) {
+        confidence += 0.4;
+        reasons.push("GDPR/CCPA");
+      }
+      if (context.touchesPayments) {
+        confidence += 0.35;
+        reasons.push("PCI-DSS");
+      }
+      if (context.patterns?.hasEmailHandling) {
+        confidence += 0.25;
+        reasons.push("CAN-SPAM");
+      }
+    }
+    if (agent.name === "accessibility") {
+      tier = 2;
+      if (context.touchesUI) {
+        confidence += 0.6;
+        reasons.push("UI components");
+      }
+      if (context.framework === "react" || context.framework === "vue") {
+        confidence += 0.2;
+        reasons.push(`${context.framework} framework`);
+      }
+      if (context.patterns?.hasFormHandling) {
+        confidence += 0.2;
+        reasons.push("form UX");
+      }
+    }
+    if (agent.name === "test") {
+      tier = 2;
+      if (context.isNewFeature) {
+        confidence += 0.4;
+        reasons.push("new feature");
+      }
+      if (context.touchesAuth) {
+        confidence += 0.35;
+        reasons.push("auth needs tests");
+      }
+      if (context.touchesPayments) {
+        confidence += 0.4;
+        reasons.push("payments need tests");
+      }
+      if (context.touchesAPI) {
+        confidence += 0.3;
+        reasons.push("API testing");
+      }
+      if (!context.hasTests) {
+        confidence += 0.2;
+        reasons.push("no existing tests");
+      }
+      if (context.complexity === "high") {
+        confidence += 0.25;
+        reasons.push("complex code");
+      }
+    }
+    if (agent.name === "software-architect") {
+      tier = 2;
+      if (context.isNewFeature) {
+        confidence += 0.35;
+        reasons.push("architecture review");
+      }
+      if (context.touchesDatabase) {
+        confidence += 0.35;
+        reasons.push("data modeling");
+      }
+      if (context.linesChanged > 200) {
+        confidence += 0.3;
+        reasons.push("large change");
+      }
+      if (context.touchesAPI) {
+        confidence += 0.25;
+        reasons.push("API design");
+      }
+      if (context.patterns?.hasWebSockets) {
+        confidence += 0.3;
+        reasons.push("real-time architecture");
+      }
+      if (context.patterns?.hasQueue) {
+        confidence += 0.3;
+        reasons.push("async architecture");
+      }
+    }
+    if (agent.name === "devops") {
+      tier = 2;
+      if (context.touchesSecurityConfig) {
+        confidence += 0.4;
+        reasons.push("security config");
+      }
+      if (context.touchesFileSystem) {
+        confidence += 0.3;
+        reasons.push("file operations");
+      }
+      if (context.touchesLogging) {
+        confidence += 0.25;
+        reasons.push("logging");
+      }
+      if (context.touchesErrorHandling) {
+        confidence += 0.2;
+        reasons.push("error handling");
+      }
+      if (context.patterns?.hasCaching) {
+        confidence += 0.25;
+        reasons.push("caching");
+      }
+      if (context.patterns?.hasRateLimiting) {
+        confidence += 0.3;
+        reasons.push("rate limiting");
+      }
+    }
+    if (agent.name === "bug-finding") {
+      tier = 2;
+      if (context.touchesPayments) {
+        confidence += 0.5;
+        reasons.push("payments = zero bugs");
+      }
+      if (context.isNewFeature) {
+        confidence += 0.3;
+        reasons.push("new code");
+      }
+      if (context.patterns?.hasAsyncCode) {
+        confidence += 0.35;
+        reasons.push("async patterns");
+      }
+      if (context.complexity === "high") {
+        confidence += 0.3;
+        reasons.push("complex logic");
+      }
+      if (context.touchesDatabase) {
+        confidence += 0.25;
+        reasons.push("data mutations");
+      }
+    }
+    if (agent.name === "user-testing") {
+      tier = 3;
+      if (context.touchesUI) {
+        confidence += 0.5;
+        reasons.push("UI changes");
+      }
+      if (context.isNewFeature && context.touchesUI) {
+        confidence += 0.3;
+        reasons.push("new UI feature");
+      }
+      if (context.patterns?.hasFormHandling) {
+        confidence += 0.25;
+        reasons.push("form UX");
+      }
+    }
+    if (agent.name === "trie_clean") {
+      tier = 2;
+      if (context.touchesUI) {
+        confidence += 0.4;
+        reasons.push("UI code");
+      }
+      if (context.isNewFeature) {
+        confidence += 0.3;
+        reasons.push("new feature");
+      }
+      if (context.framework === "react") {
+        confidence += 0.2;
+        reasons.push("React code");
+      }
+    }
+    if (agent.name === "soc2") {
+      tier = 2;
+      if (context.touchesAuth) {
+        confidence += 0.4;
+        reasons.push("authentication");
+      }
+      if (context.touchesSecurityConfig) {
+        confidence += 0.4;
+        reasons.push("security config");
+      }
+      if (context.touchesLogging) {
+        confidence += 0.3;
+        reasons.push("logging");
+      }
+      if (context.touchesAPI) {
+        confidence += 0.25;
+        reasons.push("API endpoints");
+      }
+      if (context.touchesDatabase) {
+        confidence += 0.2;
+        reasons.push("data access");
+      }
+    }
+    if (agent.name === "moneybags") {
+      tier = 3;
+      if (context.touchesPayments) {
+        confidence += 0.6;
+        reasons.push("payment code = high cost risk");
+      }
+      if (context.touchesAuth) {
+        confidence += 0.4;
+        reasons.push("auth bugs are expensive");
+      }
+      if (context.touchesHealthData) {
+        confidence += 0.5;
+        reasons.push("HIPAA violations");
+      }
+      if (context.touchesUserData) {
+        confidence += 0.3;
+        reasons.push("PII exposure costs");
+      }
+      if (context.touchesDatabase) {
+        confidence += 0.25;
+        reasons.push("data loss risk");
+      }
+      if (context.isNewFeature) {
+        confidence += 0.2;
+        reasons.push("new code risk");
+      }
+      if (riskLevel === "high" || riskLevel === "critical") {
+        confidence *= 1.3;
+        reasons.push("high-stakes context");
+      }
+    }
+    if (agent.name === "production-ready") {
+      tier = 3;
+      if (context.touchesAPI) {
+        confidence += 0.4;
+        reasons.push("API deployment");
+      }
+      if (context.touchesDatabase) {
+        confidence += 0.35;
+        reasons.push("database operations");
+      }
+      if (context.touchesAuth) {
+        confidence += 0.35;
+        reasons.push("auth system");
+      }
+      if (context.touchesPayments) {
+        confidence += 0.5;
+        reasons.push("payment processing");
+      }
+      if (context.linesChanged > 200) {
+        confidence += 0.3;
+        reasons.push("significant changes");
+      }
+      if (riskLevel === "high" || riskLevel === "critical") {
+        confidence += 0.4;
+        reasons.push("production gate check");
+      }
+    }
+    confidence = Math.min(1, confidence);
+    return { agent, confidence, reasons, tier, isCustom: false };
+  }
+  logAgentScoring(scores) {
+    console.error("\n   \u{1F4CA} Agent Confidence Scores:");
+    const sorted = [...scores].sort((a, b) => b.confidence - a.confidence);
+    for (const score of sorted) {
+      const bar = this.getConfidenceBar(score.confidence);
+      const status = score.confidence >= this.config.minConfidence ? "\u2713" : "\u2717";
+      const tierLabel = score.tier === 1 ? "[T1]" : score.tier === 2 ? "[T2]" : "[T3]";
+      const customLabel = score.isCustom ? " \u{1F4DA}" : "";
+      console.error(`      ${status} ${score.agent.name.padEnd(18)} ${tierLabel} ${bar} ${(score.confidence * 100).toFixed(0)}%${customLabel}`);
+      if (score.reasons.length > 0 && score.confidence > 0) {
+        console.error(`        \u2514\u2500 ${score.reasons.join(", ")}`);
+      }
+    }
+    console.error("");
+  }
+  getConfidenceBar(confidence) {
+    const filled = Math.round(confidence * 10);
+    const empty = 10 - filled;
+    return "\u2588".repeat(filled) + "\u2591".repeat(empty);
+  }
+  resolveDependencies(agents) {
+    const agentNames = new Set(agents.map((a) => a.name));
+    const resolved = [];
+    const added = /* @__PURE__ */ new Set();
+    const dependencies = {
+      "legal": ["privacy"],
+      // legal should see privacy issues first
+      "test": ["bug-finding"],
+      // find bugs before writing tests
+      "user-testing": ["accessibility"]
+      // accessibility before UX
+    };
+    for (const agent of agents) {
+      const deps = dependencies[agent.name] || [];
+      for (const depName of deps) {
+        if (!added.has(depName)) {
+          const depAgent = this.agentRegistry.getAgent(depName);
+          if (depAgent && agentNames.has(depName)) {
+            resolved.push(depAgent);
+            added.add(depName);
+          }
+        }
+      }
+      if (!added.has(agent.name)) {
+        resolved.push(agent);
+        added.add(agent.name);
+      }
+    }
+    return resolved;
+  }
+  getTriagingReason(context, riskLevel) {
+    if (riskLevel === "critical") {
+      return "Critical risk detected - activating all agents for comprehensive review";
+    }
+    const reasons = [];
+    if (context.touchesAuth) reasons.push("authentication");
+    if (context.touchesPayments) reasons.push("payments");
+    if (context.touchesDatabase) reasons.push("database");
+    if (context.touchesUserData) reasons.push("user data");
+    if (context.touchesUI) reasons.push("UI");
+    if (context.touchesAPI) reasons.push("API");
+    if (context.isNewFeature) reasons.push("new feature");
+    if (context.touchesCrypto) reasons.push("cryptography");
+    if (context.touchesThirdPartyAPI) reasons.push("3rd party API");
+    if (reasons.length === 0) {
+      return `${riskLevel} risk - general code changes`;
+    }
+    return `${riskLevel} risk: ${reasons.join(", ")}`;
+  }
+  async getSkippedAgents(context, riskLevel) {
+    await this.ensureCustomSkillsLoaded();
+    if (riskLevel === "critical") return [];
+    const scores = this.scoreAgents(context, riskLevel);
+    return scores.filter((s) => s.confidence < this.config.minConfidence).map((s) => s.agent.name);
+  }
+  async getTriagingConfidence(context, riskLevel) {
+    await this.ensureCustomSkillsLoaded();
+    const scores = this.scoreAgents(context, riskLevel);
+    const qualified = scores.filter((s) => s.confidence >= this.config.minConfidence);
+    if (qualified.length === 0) return 0.5;
+    const avgConfidence = qualified.reduce((sum, s) => sum + s.confidence, 0) / qualified.length;
+    const contextStrength = this.getContextStrength(context);
+    return Math.min(1, avgConfidence * 0.7 + contextStrength * 0.3);
+  }
+  getContextStrength(context) {
+    let signals = 0;
+    const checks = [
+      context.touchesAuth,
+      context.touchesPayments,
+      context.touchesDatabase,
+      context.touchesAPI,
+      context.touchesUI,
+      context.touchesUserData,
+      context.touchesHealthData,
+      context.touchesSecurityConfig,
+      context.touchesCrypto,
+      context.touchesFileSystem,
+      context.isNewFeature
+    ];
+    for (const check of checks) {
+      if (check) signals++;
+    }
+    return signals > 0 ? Math.min(1, signals / 3) : 0.3;
+  }
+  getAllAgents() {
+    return this.agentRegistry.getAllAgents();
+  }
+  /**
+   * Get custom skills count
+   */
+  getCustomSkillCount() {
+    return this.agentRegistry.getCustomSkills().length;
+  }
+  // Backward compatibility alias
+  getCustomAgentCount() {
+    return this.getCustomSkillCount();
+  }
+  /**
+   * Reload custom skills
+   */
+  async reloadCustomSkills() {
+    await this.agentRegistry.reloadCustomSkills();
+  }
+  // Backward compatibility alias
+  async reloadCustomAgents() {
+    return this.reloadCustomSkills();
+  }
+};
+
+// src/utils/parallel-executor.ts
+import { Worker } from "worker_threads";
+import { cpus } from "os";
+var ParallelExecutor = class {
+  maxWorkers;
+  cache;
+  streaming;
+  activeWorkers = /* @__PURE__ */ new Set();
+  cacheEnabled = true;
+  useWorkerThreads = false;
+  constructor(cacheManager, maxWorkers = Math.max(2, Math.min(cpus().length - 1, 8)), options) {
+    this.maxWorkers = maxWorkers;
+    this.cache = cacheManager;
+    this.cacheEnabled = options?.cacheEnabled ?? true;
+    this.useWorkerThreads = options?.useWorkerThreads ?? false;
+  }
+  /**
+   * Set streaming manager for real-time updates
+   */
+  setStreaming(streaming) {
+    this.streaming = streaming;
+  }
+  /**
+   * Execute agents in parallel with intelligent scheduling
+   */
+  async executeAgents(agents, files, context) {
+    if (agents.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    if (this.streaming && this.streaming.getProgress().totalFiles === 0) {
+      this.streaming.startScan(files.length);
+    }
+    const cacheResults = /* @__PURE__ */ new Map();
+    const uncachedTasks = [];
+    for (const agent of agents) {
+      const cached = await this.checkAgentCache(agent, files);
+      if (cached) {
+        cacheResults.set(agent.name, cached);
+        this.streaming?.completeAgent(agent.name, cached.issues);
+      } else {
+        uncachedTasks.push({
+          agent,
+          files,
+          context,
+          priority: agent.priority?.tier || 2,
+          timeoutMs: context?.config?.timeoutMs || 12e4
+        });
+      }
+    }
+    uncachedTasks.sort((a, b) => a.priority - b.priority);
+    const parallelResults = await this.executeTasksParallel(uncachedTasks);
+    await this.cacheResults(parallelResults);
+    const allResults = /* @__PURE__ */ new Map();
+    for (const [agent, result] of cacheResults) {
+      allResults.set(agent, result);
+    }
+    for (const result of parallelResults) {
+      allResults.set(result.agent, result.result);
+    }
+    const allIssues = Array.from(allResults.values()).flatMap((r) => r.issues);
+    this.streaming?.completeScan(allIssues);
+    return allResults;
+  }
+  /**
+   * Check if agent has cached results for given files
+   */
+  async checkAgentCache(agent, files) {
+    if (!this.cacheEnabled || !this.cache) {
+      return null;
+    }
+    const cachedIssues = await this.cache.getCachedBatch(files, agent.name);
+    if (cachedIssues.size === files.length) {
+      const allIssues = Array.from(cachedIssues.values()).flat();
+      return {
+        agent: agent.name,
+        issues: allIssues,
+        executionTime: 0,
+        // Cached
+        success: true,
+        metadata: {
+          filesAnalyzed: files.length,
+          linesAnalyzed: 0
+        }
+      };
+    }
+    return null;
+  }
+  /**
+   * Execute tasks in parallel batches
+   */
+  async executeTasksParallel(tasks) {
+    if (tasks.length === 0) {
+      return [];
+    }
+    const results = [];
+    const batches = this.createBatches(tasks, this.maxWorkers);
+    for (const batch of batches) {
+      const batchResults = await Promise.all(
+        batch.map((task) => this.executeTask(task))
+      );
+      results.push(...batchResults);
+    }
+    return results;
+  }
+  /**
+   * Create batches for parallel execution
+   */
+  createBatches(tasks, batchSize) {
+    const batches = [];
+    for (let i = 0; i < tasks.length; i += batchSize) {
+      batches.push(tasks.slice(i, i + batchSize));
+    }
+    return batches;
+  }
+  /**
+   * Execute a single task
+   */
+  async executeTask(task) {
+    const startTime = Date.now();
+    this.streaming?.startAgent(task.agent.name);
+    try {
+      const result = this.useWorkerThreads ? await this.executeTaskInWorker(task) : await task.agent.scan(task.files, task.context);
+      const executionTime = Date.now() - startTime;
+      this.streaming?.completeAgent(task.agent.name, result.issues);
+      return {
+        agent: task.agent.name,
+        result,
+        fromCache: false,
+        executionTime
+      };
+    } catch (error) {
+      const executionTime = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.streaming?.reportError(new Error(errorMessage), `Agent: ${task.agent.name}`);
+      return {
+        agent: task.agent.name,
+        result: {
+          agent: task.agent.name,
+          issues: [],
+          executionTime,
+          success: false,
+          error: errorMessage
+        },
+        fromCache: false,
+        executionTime
+      };
+    }
+  }
+  async executeTaskInWorker(task) {
+    const distDir = new URL(".", import.meta.url);
+    const workerUrl = new URL("workers/agent-worker.js", distDir);
+    return new Promise((resolve, reject) => {
+      const worker = new Worker(workerUrl, {
+        workerData: {
+          agentName: task.agent.name,
+          files: task.files,
+          context: task.context
+        }
+      });
+      this.activeWorkers.add(worker);
+      const timeout = setTimeout(() => {
+        worker.terminate().catch(() => void 0);
+        reject(new Error(`Agent ${task.agent.name} timed out after ${task.timeoutMs}ms`));
+      }, task.timeoutMs);
+      worker.on("message", (message) => {
+        if (message?.type === "result") {
+          clearTimeout(timeout);
+          resolve(message.result);
+        } else if (message?.type === "error") {
+          clearTimeout(timeout);
+          reject(new Error(message.error));
+        }
+      });
+      worker.on("error", (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      });
+      worker.on("exit", (code) => {
+        this.activeWorkers.delete(worker);
+        if (code !== 0) {
+          clearTimeout(timeout);
+          reject(new Error(`Worker stopped with exit code ${code}`));
+        }
+      });
+    });
+  }
+  /**
+   * Cache results for future use
+   */
+  async cacheResults(results) {
+    if (!this.cacheEnabled || !this.cache) {
+      return;
+    }
+    const cachePromises = results.filter((r) => r.result.success && !r.fromCache).map((r) => {
+      const issuesByFile = this.groupIssuesByFile(r.result.issues);
+      const perFilePromises = Object.entries(issuesByFile).map(
+        ([file, issues]) => this.cache.setCached(file, r.agent, issues, r.executionTime)
+      );
+      return Promise.all(perFilePromises);
+    });
+    await Promise.allSettled(cachePromises);
+  }
+  /**
+   * Cleanup resources
+   */
+  async cleanup() {
+    const terminationPromises = Array.from(this.activeWorkers).map(
+      (worker) => worker.terminate()
+    );
+    await Promise.allSettled(terminationPromises);
+    this.activeWorkers.clear();
+  }
+  groupIssuesByFile(issues) {
+    const grouped = {};
+    for (const issue of issues) {
+      if (!grouped[issue.file]) {
+        grouped[issue.file] = [];
+      }
+      grouped[issue.file].push(issue);
+    }
+    return grouped;
+  }
+};
+function calculateOptimalConcurrency() {
+  const numCPUs = cpus().length;
+  const availableMemoryGB = process.memoryUsage().rss / 1024 / 1024 / 1024;
+  let optimal = Math.max(2, Math.min(numCPUs - 1, 8));
+  if (availableMemoryGB < 2) {
+    optimal = Math.max(2, Math.floor(optimal / 2));
+  }
+  if (numCPUs > 8) {
+    optimal = Math.min(optimal + 2, 12);
+  }
+  return optimal;
+}
+
+// src/utils/cache-manager.ts
+import { readFile, writeFile, mkdir, stat } from "fs/promises";
+import { join } from "path";
+import { createHash } from "crypto";
+var CacheManager = class {
+  cacheDir;
+  indexPath;
+  VERSION = "1.0.0";
+  MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+  // 24 hours
+  MAX_ENTRIES = 1e3;
+  constructor(baseDir) {
+    this.cacheDir = join(baseDir, ".trie", "cache");
+    this.indexPath = join(this.cacheDir, "index.json");
+  }
+  /**
+   * Generate cache key for a file and agent combination
+   */
+  generateCacheKey(filePath, agent, fileHash) {
+    const key = `${filePath}:${agent}:${fileHash}`;
+    return createHash("sha256").update(key).digest("hex").slice(0, 16);
+  }
+  /**
+   * Get file hash for cache validation
+   */
+  async getFileHash(filePath) {
+    try {
+      const content = await readFile(filePath, "utf-8");
+      const stats = await stat(filePath);
+      const hash = createHash("sha256").update(content).digest("hex").slice(0, 16);
+      return {
+        hash,
+        size: stats.size,
+        mtime: stats.mtime.getTime()
+      };
+    } catch {
+      return { hash: "", size: 0, mtime: 0 };
+    }
+  }
+  /**
+   * Load cache index
+   */
+  async loadIndex() {
+    try {
+      const content = await readFile(this.indexPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return {
+        version: this.VERSION,
+        created: Date.now(),
+        entries: {}
+      };
+    }
+  }
+  /**
+   * Save cache index
+   */
+  async saveIndex(index) {
+    try {
+      await mkdir(this.cacheDir, { recursive: true });
+      await writeFile(this.indexPath, JSON.stringify(index, null, 2));
+    } catch (error) {
+      console.warn("Failed to save cache index:", error);
+    }
+  }
+  /**
+   * Clean up expired entries
+   */
+  cleanupExpired(index) {
+    const now = Date.now();
+    const validEntries = {};
+    for (const [key, entry] of Object.entries(index.entries)) {
+      if (now - entry.timestamp < this.MAX_AGE_MS) {
+        validEntries[key] = entry;
+      }
+    }
+    const entries = Object.entries(validEntries);
+    if (entries.length > this.MAX_ENTRIES) {
+      entries.sort((a, b) => b[1].timestamp - a[1].timestamp);
+      const limited = entries.slice(0, this.MAX_ENTRIES);
+      return {
+        ...index,
+        entries: Object.fromEntries(limited)
+      };
+    }
+    return {
+      ...index,
+      entries: validEntries
+    };
+  }
+  /**
+   * Get cached result for a file and agent
+   */
+  async getCached(filePath, agent) {
+    try {
+      const { hash, size: _size, mtime: _mtime } = await this.getFileHash(filePath);
+      if (!hash) return null;
+      const index = await this.loadIndex();
+      const cacheKey = this.generateCacheKey(filePath, agent, hash);
+      const entry = index.entries[cacheKey];
+      if (!entry) return null;
+      const isValid = entry.fileHash === hash && entry.version === this.VERSION && Date.now() - entry.timestamp < this.MAX_AGE_MS;
+      if (!isValid) {
+        delete index.entries[cacheKey];
+        await this.saveIndex(index);
+        return null;
+      }
+      return entry.issues;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Cache result for a file and agent
+   */
+  async setCached(filePath, agent, issues, executionTime) {
+    try {
+      const { hash, size } = await this.getFileHash(filePath);
+      if (!hash) return;
+      const index = await this.loadIndex();
+      const cacheKey = this.generateCacheKey(filePath, agent, hash);
+      index.entries[cacheKey] = {
+        version: this.VERSION,
+        timestamp: Date.now(),
+        fileHash: hash,
+        fileSize: size,
+        agent,
+        issues,
+        executionTime
+      };
+      const cleanedIndex = this.cleanupExpired(index);
+      await this.saveIndex(cleanedIndex);
+    } catch (error) {
+      console.warn("Failed to cache result:", error);
+    }
+  }
+  /**
+   * Check if multiple files have cached results
+   */
+  async getCachedBatch(files, agent) {
+    const results = /* @__PURE__ */ new Map();
+    await Promise.all(
+      files.map(async (file) => {
+        const cached = await this.getCached(file, agent);
+        if (cached) {
+          results.set(file, cached);
+        }
+      })
+    );
+    return results;
+  }
+  /**
+   * Get cache statistics
+   */
+  async getStats() {
+    try {
+      const index = await this.loadIndex();
+      const entries = Object.values(index.entries);
+      const totalSizeKB = entries.reduce((acc, entry) => acc + entry.fileSize, 0) / 1024;
+      const timestamps = entries.map((e) => e.timestamp);
+      const agents = [...new Set(entries.map((e) => e.agent))];
+      return {
+        totalEntries: entries.length,
+        totalSizeKB: Math.round(totalSizeKB),
+        oldestEntry: timestamps.length > 0 ? Math.min(...timestamps) : null,
+        newestEntry: timestamps.length > 0 ? Math.max(...timestamps) : null,
+        agents
+      };
+    } catch {
+      return {
+        totalEntries: 0,
+        totalSizeKB: 0,
+        oldestEntry: null,
+        newestEntry: null,
+        agents: []
+      };
+    }
+  }
+  /**
+   * Clear all cache
+   */
+  async clear() {
+    try {
+      const emptyIndex = {
+        version: this.VERSION,
+        created: Date.now(),
+        entries: {}
+      };
+      await this.saveIndex(emptyIndex);
+    } catch (error) {
+      console.warn("Failed to clear cache:", error);
+    }
+  }
+};
+
+// src/orchestrator/executor.ts
+var Executor = class {
+  async executeAgents(agents, files, context, options) {
+    const parallel = options?.parallel ?? true;
+    const cacheEnabled = options?.cacheEnabled ?? true;
+    const maxConcurrency = options?.maxConcurrency ?? calculateOptimalConcurrency();
+    const useWorkerThreads = options?.useWorkerThreads ?? false;
+    console.error(`\u26A1 Executing ${agents.length} agents ${parallel ? "in parallel" : "sequentially"}...`);
+    if (parallel) {
+      const cacheManager = cacheEnabled ? new CacheManager(context.workingDir) : null;
+      const executor = new ParallelExecutor(cacheManager, maxConcurrency, {
+        cacheEnabled,
+        useWorkerThreads
+      });
+      if (options?.streaming) {
+        executor.setStreaming(options.streaming);
+      }
+      const results = await executor.executeAgents(agents, files, {
+        ...context,
+        config: { timeoutMs: options?.timeoutMs ?? 12e4 }
+      });
+      return agents.map((agent) => results.get(agent.name)).filter(Boolean);
+    }
+    const promises = agents.map(
+      (agent) => this.executeAgentWithTimeout(agent, files, context, options?.timeoutMs ?? 3e4)
+    );
+    try {
+      const results = await Promise.allSettled(promises);
+      return results.map((result, index) => {
+        if (result.status === "fulfilled") {
+          console.error(`\u2705 ${agents[index].name} completed in ${result.value.executionTime}ms`);
+          return result.value;
+        } else {
+          console.error(`\u274C ${agents[index].name} failed:`, result.reason);
+          return {
+            agent: agents[index].name,
+            issues: [],
+            executionTime: 0,
+            success: false,
+            error: result.reason instanceof Error ? result.reason.message : String(result.reason)
+          };
+        }
+      });
+    } catch (error) {
+      console.error("Executor error:", error);
+      return agents.map((agent) => ({
+        agent: agent.name,
+        issues: [],
+        executionTime: 0,
+        success: false,
+        error: "Execution failed"
+      }));
+    }
+  }
+  async executeAgentWithTimeout(agent, files, context, timeoutMs = 3e4) {
+    return new Promise(async (resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error(`Agent ${agent.name} timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      try {
+        const result = await agent.scan(files, context);
+        clearTimeout(timeout);
+        resolve(result);
+      } catch (error) {
+        clearTimeout(timeout);
+        reject(error);
+      }
+    });
+  }
+};
+
+export {
+  Triager,
+  Executor
+};
+//# sourceMappingURL=chunk-C3AS5OXW.js.map