@triedotdev/mcp 1.0.168 → 1.0.170

package/dist/chunk-YZ6Y2H3P.js

@@ -1,1289 +0,0 @@
-import {
-  IncidentIndex
-} from "./chunk-TN5WEKWI.js";
-import {
-  TriePatternDiscovery
-} from "./chunk-ZV2K6M7T.js";
-import {
-  scanForVulnerabilities
-} from "./chunk-SY6KQG44.js";
-import {
-  scanForVibeCodeIssues
-} from "./chunk-OMR4YCBS.js";
-import {
-  ContextGraph
-} from "./chunk-VUL52BQL.js";
-import {
-  storeIssues
-} from "./chunk-XE6KQRKZ.js";
-import {
-  getTrieDirectory,
-  getWorkingDirectory
-} from "./chunk-VVITXIHN.js";
-import {
-  isInteractiveMode
-} from "./chunk-KDHN2ZQE.js";
-import {
-  getDiff,
-  getRecentCommits,
-  getStagedChanges,
-  getUncommittedChanges,
-  getWorkingTreeDiff
-} from "./chunk-2HF65EHQ.js";
-
-// src/utils/trie-init.ts
-import { existsSync } from "fs";
-import { join } from "path";
-var INIT_MARKERS = [
-  "PROJECT.md",
-  "RULES.md",
-  "TEAM.md",
-  "BOOTSTRAP.md",
-  "AGENTS.md",
-  "config.json"
-];
-function isTrieInitialized(workDir) {
-  const dir = workDir || getWorkingDirectory(void 0, true);
-  const trieDir = getTrieDirectory(dir);
-  return INIT_MARKERS.some((marker) => existsSync(join(trieDir, marker)));
-}
-
-// src/utils/errors.ts
-var TrieError = class extends Error {
-  code;
-  recoverable;
-  userMessage;
-  constructor(message, code, userMessage, recoverable = true) {
-    super(message);
-    this.code = code;
-    this.recoverable = recoverable;
-    this.userMessage = userMessage;
-  }
-};
-function formatFriendlyError(error) {
-  if (error instanceof TrieError) {
-    return { userMessage: error.userMessage, code: error.code };
-  }
-  return {
-    userMessage: "Something went wrong. Try again or run with --offline.",
-    code: "UNKNOWN"
-  };
-}
-
-// src/agent/confidence.ts
-function adjustConfidence(current, outcome, step = 0.1) {
-  const delta = outcome === "positive" ? step : -step;
-  return clamp(current + delta);
-}
-function clamp(value) {
-  if (Number.isNaN(value)) return 0.5;
-  return Math.min(1, Math.max(0, value));
-}
-
-// src/agent/learning.ts
-var LearningSystem = class {
-  constructor(graph, projectPath) {
-    this.graph = graph;
-    this.incidentIndex = new IncidentIndex(graph, projectPath);
-    this.discovery = new TriePatternDiscovery(graph, this.incidentIndex);
-  }
-  incidentIndex;
-  discovery;
-  async onWarningHeeded(files) {
-    await this.adjustPatterns(files, "positive");
-  }
-  async onWarningIgnored(files) {
-    await this.adjustPatterns(files, "negative");
-  }
-  async onIncidentReported(incidentId, files) {
-    const incident = await this.graph.getNode("incident", incidentId);
-    if (incident && incident.type === "incident") {
-      this.incidentIndex.addIncidentToTrie(incident, files);
-    }
-    await this.discoverAndStorePatterns();
-  }
-  async onFeedback(helpful, files = []) {
-    await this.adjustPatterns(files, helpful ? "positive" : "negative");
-  }
-  async adjustPatterns(files, outcome) {
-    if (!files.length) return;
-    for (const file of files) {
-      const patterns = await this.graph.getPatternsForFile(file);
-      await Promise.all(patterns.map((p) => this.updatePatternConfidence(p, outcome)));
-    }
-  }
-  async updatePatternConfidence(pattern, outcome) {
-    const current = pattern.data.confidence ?? 0.5;
-    const updated = adjustConfidence(current, outcome, 0.05);
-    await this.graph.updateNode("pattern", pattern.id, { confidence: updated, lastSeen: (/* @__PURE__ */ new Date()).toISOString() });
-  }
-  async discoverAndStorePatterns() {
-    const hotPatterns = this.discovery.discoverHotPatterns();
-    for (const hot of hotPatterns) {
-      await this.graph.addNode("pattern", {
-        description: `${hot.type === "directory" ? "Directory" : "File"} hot zone: ${hot.path}`,
-        appliesTo: [hot.path],
-        confidence: hot.confidence,
-        occurrences: hot.incidentCount,
-        firstSeen: (/* @__PURE__ */ new Date()).toISOString(),
-        lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
-        isAntiPattern: true,
-        source: "local"
-      });
-    }
-  }
-};
-
-// src/agent/learning-engine.ts
-import path from "path";
-var LearningEngine = class {
-  projectPath;
-  graph;
-  learningSystem;
-  constructor(projectPath, graph) {
-    this.projectPath = projectPath;
-    this.graph = graph || new ContextGraph(projectPath);
-    this.learningSystem = new LearningSystem(this.graph, projectPath);
-  }
-  /**
-   * Unified learning method: Scans history AND processes manual feedback
-   */
-  async learn(options = {}) {
-    const results = [];
-    if (!options.manualFeedback) {
-      const implicitCount = await this.learnFromHistory(options.limit || 20);
-      results.push({ learned: implicitCount, source: "git-history" });
-    }
-    if (options.manualFeedback) {
-      await this.recordManualFeedback(
-        options.manualFeedback.helpful,
-        options.manualFeedback.files,
-        options.manualFeedback.note
-      );
-      results.push({ learned: options.manualFeedback.files.length || 1, source: "manual-feedback" });
-    }
-    return results;
-  }
-  /**
-   * Scan recent commits for implicit failure signals (reverts, fixes)
-   */
-  async learnFromHistory(limit = 20) {
-    const commits = await getRecentCommits(this.projectPath, limit);
-    const issuesToStore = [];
-    for (const commit of commits) {
-      const isRevert = commit.message.toLowerCase().includes("revert") || commit.message.startsWith('Revert "');
-      const isFix = /fix(es|ed)?\s+#\d+/i.test(commit.message) || commit.message.toLowerCase().includes("bugfix");
-      if (isRevert || isFix) {
-        const type = isRevert ? "revert" : "fix";
-        const diff = await getDiff(this.projectPath, commit.hash);
-        const files = this.extractFilesFromDiff(diff);
-        for (const file of files) {
-          const learnedIssues = await this.extractIssuesFromDiff(diff, file, type, commit.message);
-          issuesToStore.push(...learnedIssues);
-        }
-      }
-    }
-    if (issuesToStore.length > 0) {
-      const result = await storeIssues(issuesToStore, path.basename(this.projectPath), this.projectPath);
-      return result.stored;
-    }
-    return 0;
-  }
-  /**
-   * Record manual feedback (trie ok/bad) and adjust pattern confidence
-   */
-  async recordManualFeedback(helpful, files, note) {
-    const context = files[0] ?? "unspecified";
-    const decision = await this.graph.addNode("decision", {
-      context,
-      decision: helpful ? "helpful" : "not helpful",
-      reasoning: note ?? null,
-      outcome: helpful ? "good" : "bad",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    if (files.length > 0) {
-      for (const file of files) {
-        const fileNode = await this.graph.getNode("file", file);
-        if (fileNode) {
-          await this.graph.addEdge(decision.id, fileNode.id, "affects");
-        }
-      }
-      await this.learningSystem.onFeedback(helpful, files);
-    }
-  }
-  extractFilesFromDiff(diff) {
-    const files = /* @__PURE__ */ new Set();
-    const lines = diff.split("\n");
-    for (const line of lines) {
-      if (line.startsWith("+++ b/")) {
-        files.add(line.slice(6));
-      }
-    }
-    return Array.from(files);
-  }
-  async extractIssuesFromDiff(diff, file, type, message) {
-    const issues = [];
-    const badLines = this.getBadLinesFromDiff(diff, file, type);
-    const content = badLines.join("\n");
-    if (!content) return [];
-    const vulnerabilities = await scanForVulnerabilities(content, file);
-    const vibeIssues = await scanForVibeCodeIssues(content, file);
-    const allMatches = [...vulnerabilities, ...vibeIssues];
-    for (const match of allMatches) {
-      issues.push({
-        id: `implicit-${type}-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
-        severity: "serious",
-        issue: `Implicit failure detected via ${type}: ${message}. Linked to pattern: ${match.category}`,
-        fix: `Review the ${type} commit and avoid this pattern in ${file}.`,
-        file,
-        confidence: 0.7,
-        autoFixable: false,
-        agent: "implicit-learning",
-        category: match.category
-      });
-    }
-    if (issues.length === 0) {
-      issues.push({
-        id: `implicit-${type}-${Date.now()}`,
-        severity: "moderate",
-        issue: `Historical ${type} detected: ${message}`,
-        fix: `Review the changes in ${file} from this commit to avoid regression.`,
-        file,
-        confidence: 0.5,
-        autoFixable: false,
-        agent: "implicit-learning"
-      });
-    }
-    return issues;
-  }
-  getBadLinesFromDiff(diff, file, type) {
-    const badLines = [];
-    const lines = diff.split("\n");
-    let inTargetFile = false;
-    for (const line of lines) {
-      if (line.startsWith("+++ b/") || line.startsWith("--- a/")) {
-        inTargetFile = line.includes(file);
-        continue;
-      }
-      if (!inTargetFile) continue;
-      if (type === "fix" && line.startsWith("-") && !line.startsWith("---")) {
-        badLines.push(line.slice(1));
-      } else if (type === "revert" && line.startsWith("+") && !line.startsWith("+++")) {
-        badLines.push(line.slice(1));
-      }
-    }
-    return badLines;
-  }
-};
-
-// src/agent/perceive.ts
-import path2 from "path";
-
-// src/agent/diff-analyzer.ts
-var RISKY_PATTERNS = [/auth/i, /token/i, /password/i, /secret/i, /validate/i, /sanitize/i];
-function analyzeDiff(diff) {
-  const files = [];
-  let current = null;
-  const lines = diff.split("\n");
-  for (const line of lines) {
-    if (line.startsWith("+++ b/")) {
-      const filePath = line.replace("+++ b/", "").trim();
-      current = {
-        filePath,
-        added: 0,
-        removed: 0,
-        functionsModified: [],
-        riskyPatterns: []
-      };
-      files.push(current);
-      continue;
-    }
-    if (!current) {
-      continue;
-    }
-    if (line.startsWith("@@")) {
-      const match = line.match(/@@.*?(function\s+([\w$]+)|class\s+([\w$]+)|([\w$]+\s*\())/i);
-      const fnName = match?.[2] || match?.[3] || match?.[4];
-      if (fnName) {
-        current.functionsModified.push(fnName.replace("(", "").trim());
-      }
-      continue;
-    }
-    if (line.startsWith("+") && !line.startsWith("+++")) {
-      current.added += 1;
-      markRisk(line, current);
-    } else if (line.startsWith("-") && !line.startsWith("---")) {
-      current.removed += 1;
-      markRisk(line, current);
-    }
-  }
-  const totalAdded = files.reduce((acc, f) => acc + f.added, 0);
-  const totalRemoved = files.reduce((acc, f) => acc + f.removed, 0);
-  const riskyFiles = files.filter((f) => f.riskyPatterns.length > 0).map((f) => f.filePath);
-  return {
-    files,
-    totalAdded,
-    totalRemoved,
-    riskyFiles
-  };
-}
-function markRisk(line, file) {
-  for (const pattern of RISKY_PATTERNS) {
-    if (pattern.test(line)) {
-      const label = pattern.toString();
-      if (!file.riskyPatterns.includes(label)) {
-        file.riskyPatterns.push(label);
-      }
-    }
-  }
-}
-
-// src/agent/perceive.ts
-async function perceiveCurrentChanges(projectPath, graph) {
-  const ctxGraph = graph ?? new ContextGraph(projectPath);
-  const [staged, unstaged] = await Promise.all([
-    getStagedChanges(projectPath),
-    getUncommittedChanges(projectPath)
-  ]);
-  const stagedDiff = await getWorkingTreeDiff(projectPath, true);
-  const unstagedDiff = await getWorkingTreeDiff(projectPath, false);
-  const combinedDiff = [stagedDiff, unstagedDiff].filter(Boolean).join("\n");
-  const diffSummary = analyzeDiff(combinedDiff);
-  const filesTouched = /* @__PURE__ */ new Set();
-  staged.forEach((c) => filesTouched.add(c.path));
-  unstaged.forEach((c) => filesTouched.add(c.path));
-  diffSummary.files.forEach((f) => filesTouched.add(f.filePath));
-  const changeId = await upsertWorkingChange(ctxGraph, Array.from(filesTouched), projectPath);
-  const result = {
-    staged,
-    unstaged,
-    diffSummary
-  };
-  if (changeId) result.changeNodeId = changeId;
-  return result;
-}
-async function upsertWorkingChange(graph, files, projectPath) {
-  if (files.length === 0) return void 0;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const change = await graph.addNode("change", {
-    commitHash: null,
-    files,
-    message: "workspace changes",
-    diff: null,
-    author: null,
-    timestamp: now,
-    outcome: "unknown"
-  });
-  for (const filePath of files) {
-    const fileNode = await ensureFileNode(graph, filePath, projectPath);
-    await graph.addEdge(change.id, fileNode.id, "affects");
-  }
-  return change.id;
-}
-async function ensureFileNode(graph, filePath, projectPath) {
-  const normalized = path2.resolve(projectPath, filePath);
-  const existing = await graph.getNode("file", normalized);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  if (existing) {
-    const data2 = existing.data;
-    await graph.updateNode("file", existing.id, {
-      changeCount: (data2.changeCount ?? 0) + 1,
-      lastChanged: now
-    });
-    return await graph.getNode("file", existing.id);
-  }
-  const data = {
-    path: filePath,
-    extension: path2.extname(filePath),
-    purpose: "",
-    riskLevel: "medium",
-    whyRisky: null,
-    changeCount: 1,
-    lastChanged: now,
-    incidentCount: 0,
-    createdAt: now
-  };
-  return await graph.addNode("file", data);
-}
-
-// src/agent/risk-scorer.ts
-import * as path3 from "path";
-var BASE_RISK = {
-  low: 10,
-  medium: 35,
-  high: 65,
-  critical: 85
-};
-var SENSITIVE_PATHS = [
-  { pattern: /auth|login|token|session/i, weight: 20, reason: "touches authentication" },
-  { pattern: /payment|billing|stripe|paypal|checkout/i, weight: 25, reason: "touches payments" },
-  { pattern: /secret|credential|env|config\/security/i, weight: 15, reason: "touches secrets/security config" }
-];
-function levelFromScore(score) {
-  if (score >= 90) return "critical";
-  if (score >= 65) return "high";
-  if (score >= 40) return "medium";
-  return "low";
-}
-async function scoreFile(graph, filePath, matchedPatterns = []) {
-  const reasons = [];
-  const normalized = path3.resolve(graph.projectRoot, filePath);
-  const node = await graph.getNode("file", normalized);
-  const incidents = await graph.getIncidentsForFile(filePath);
-  let score = 10;
-  const data = node?.data;
-  if (data) {
-    score = BASE_RISK[data.riskLevel] ?? score;
-    reasons.push(`baseline ${data.riskLevel}`);
-    if (data.incidentCount > 0) {
-      const incBoost = Math.min(data.incidentCount * 12, 36);
-      score += incBoost;
-      reasons.push(`historical incidents (+${incBoost})`);
-    }
-    if (data.changeCount > 5) {
-      const changeBoost = Math.min((data.changeCount - 5) * 2, 12);
-      score += changeBoost;
-      reasons.push(`frequent changes (+${changeBoost})`);
-    }
-    if (data.lastChanged) {
-      const lastChanged = new Date(data.lastChanged).getTime();
-      const days = (Date.now() - lastChanged) / (1e3 * 60 * 60 * 24);
-      if (days > 60 && data.incidentCount === 0) {
-        score -= 5;
-        reasons.push("stable for 60d (-5)");
-      }
-    }
-  }
-  for (const { pattern, weight, reason } of SENSITIVE_PATHS) {
-    if (pattern.test(filePath)) {
-      score += weight;
-      reasons.push(reason);
-    }
-  }
-  if (matchedPatterns.length > 0) {
-    const patternBoost = Math.min(
-      matchedPatterns.reduce((acc, p) => acc + (p.data.confidence ?? 50) / 10, 0),
-      20
-    );
-    score += patternBoost;
-    reasons.push(`pattern match (+${Math.round(patternBoost)})`);
-  }
-  if (incidents.length > 0) {
-    const timestamps = incidents.map((i) => new Date(i.data.timestamp).getTime()).sort((a, b) => b - a);
-    const recent = timestamps[0];
-    const daysSince = (Date.now() - recent) / (1e3 * 60 * 60 * 24);
-    if (daysSince > 90) {
-      score -= 5;
-      reasons.push("no incidents in 90d (-5)");
-    } else {
-      score += 8;
-      reasons.push("recent incident (+8)");
-    }
-  }
-  const level = levelFromScore(score);
-  return {
-    file: filePath,
-    score,
-    level,
-    reasons,
-    incidents,
-    matchedPatterns
-  };
-}
-async function scoreChangeSet(graph, files, patternMatches = {}) {
-  const fileResults = [];
-  for (const file of files) {
-    const patterns = patternMatches[file] ?? [];
-    fileResults.push(await scoreFile(graph, file, patterns));
-  }
-  const maxScore = Math.max(...fileResults.map((f) => f.score), 10);
-  const spreadBoost = files.length > 5 ? Math.min((files.length - 5) * 2, 10) : 0;
-  const overallScore = maxScore + spreadBoost;
-  const overall = levelFromScore(overallScore);
-  const shouldEscalate = overall === "critical" || overall === "high";
-  return {
-    files: fileResults,
-    overall,
-    score: overallScore,
-    shouldEscalate
-  };
-}
-
-// src/agent/pattern-matcher.ts
-async function matchPatternsForFiles(graph, files) {
-  const matches = [];
-  const byFile = {};
-  for (const file of files) {
-    const patterns = await graph.getPatternsForFile(file);
-    if (patterns.length === 0) continue;
-    byFile[file] = patterns;
-    for (const pattern of patterns) {
-      matches.push({
-        file,
-        pattern,
-        confidence: pattern.data.confidence,
-        isAntiPattern: pattern.data.isAntiPattern
-      });
-    }
-  }
-  return { matches, byFile };
-}
-
-// src/orchestrator/triager.ts
-var Triager = class {
-  constructor(_config) {
-  }
-  /**
-   * Triage a change to select appropriate agents
-   * Note: Skills/agents have been removed - Trie is now purely a decision ledger
-   */
-  async triage(_context, _forceAgents) {
-    return [];
-  }
-  /**
-   * Get all available agent names (deprecated - returns empty array)
-   */
-  getAvailableAgents() {
-    return [];
-  }
-};
-
-// src/utils/parallel-executor.ts
-import { Worker } from "worker_threads";
-import { cpus } from "os";
-import { existsSync as existsSync2 } from "fs";
-import { fileURLToPath } from "url";
-var ParallelExecutor = class {
-  maxWorkers;
-  cache;
-  streaming;
-  activeWorkers = /* @__PURE__ */ new Set();
-  cacheEnabled = true;
-  useWorkerThreads = false;
-  workerAvailable = null;
-  warnedWorkerFallback = 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 Array.from(cacheResults.entries())) {
-      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.canUseWorkers() ? 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
-      };
-    }
-  }
-  canUseWorkers() {
-    if (!this.useWorkerThreads) {
-      return false;
-    }
-    if (this.workerAvailable !== null) {
-      return this.workerAvailable;
-    }
-    const workerUrl = this.getWorkerUrl();
-    this.workerAvailable = existsSync2(fileURLToPath(workerUrl));
-    if (!this.workerAvailable && !this.warnedWorkerFallback && !isInteractiveMode()) {
-      console.error("Worker threads unavailable; falling back to in-process agents.");
-      this.warnedWorkerFallback = true;
-    }
-    return this.workerAvailable;
-  }
-  getWorkerUrl() {
-    const distDir = new URL(".", import.meta.url);
-    return new URL("workers/agent-worker.js", distDir);
-  }
-  async executeTaskInWorker(task) {
-    const workerUrl = this.getWorkerUrl();
-    return new Promise((resolve2, 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);
-          resolve2(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 as join2 } 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 = join2(getTrieDirectory(baseDir), "cache");
-    this.indexPath = join2(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) {
-      if (!isInteractiveMode()) {
-        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
-   * 
-   * Cache automatically invalidates when files change:
-   * - Cache key includes file hash: hash(filePath:agent:fileHash)
-   * - When file changes, hash changes, so cache key changes
-   * - Old cache entry won't be found (different key)
-   * - File is automatically rescanned
-   * 
-   * This means cache auto-updates when Claude fixes code - no manual invalidation needed!
-   */
-  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) {
-      if (!isInteractiveMode()) {
-        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 = Array.from(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: []
-      };
-    }
-  }
-  /**
-   * Clean up stale cache entries by verifying file hashes
-   * This removes entries where files have changed or no longer exist
-   * Called periodically to keep cache clean
-   * 
-   * Note: Since cache keys are hashed, we can't easily reverse-engineer file paths.
-   * However, when getCached() is called, it naturally invalidates stale entries
-   * by checking if the current file hash matches the cached hash. This method
-   * proactively cleans up entries for known changed files.
-   */
-  async cleanupStaleEntries(filePaths) {
-    try {
-      const index = await this.loadIndex();
-      let removedCount = 0;
-      const keysToRemove = [];
-      if (filePaths && filePaths.length > 0) {
-        const agents = /* @__PURE__ */ new Set();
-        for (const entry of Object.values(index.entries)) {
-          agents.add(entry.agent);
-        }
-        for (const filePath of filePaths) {
-          try {
-            const { hash: currentHash } = await this.getFileHash(filePath);
-            if (!currentHash) {
-              continue;
-            }
-            for (const agent of Array.from(agents)) {
-              for (const [key, entry] of Object.entries(index.entries)) {
-                if (entry.agent !== agent) continue;
-                if (entry.fileHash !== currentHash) {
-                  const oldKey = this.generateCacheKey(filePath, agent, entry.fileHash);
-                  if (oldKey === key) {
-                    keysToRemove.push(key);
-                    removedCount++;
-                  }
-                }
-              }
-            }
-          } catch {
-            continue;
-          }
-        }
-      }
-      const uniqueKeys = Array.from(new Set(keysToRemove));
-      for (const key of uniqueKeys) {
-        delete index.entries[key];
-      }
-      if (removedCount > 0) {
-        await this.saveIndex(index);
-      }
-      return removedCount;
-    } catch (error) {
-      if (!isInteractiveMode()) {
-        console.warn("Failed to cleanup stale cache entries:", error);
-      }
-      return 0;
-    }
-  }
-  /**
-   * Clear all cache
-   */
-  async clear() {
-    try {
-      const emptyIndex = {
-        version: this.VERSION,
-        created: Date.now(),
-        entries: {}
-      };
-      await this.saveIndex(emptyIndex);
-    } catch (error) {
-      if (!isInteractiveMode()) {
-        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;
-    if (!isInteractiveMode()) {
-      console.error(`Executing ${agents.length} scouts ${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") {
-          if (!isInteractiveMode()) {
-            console.error(`${agents[index].name} completed in ${result.value.executionTime}ms`);
-          }
-          return result.value;
-        } else {
-          if (!isInteractiveMode()) {
-            console.error(`${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) {
-      if (!isInteractiveMode()) {
-        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 (resolve2, 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);
-        resolve2(result);
-      } catch (error) {
-        clearTimeout(timeout);
-        reject(error);
-      }
-    });
-  }
-};
-
-// src/agent/reason.ts
-function buildDefaultCodeContext() {
-  return {
-    changeType: "general",
-    isNewFeature: false,
-    touchesUserData: false,
-    touchesAuth: false,
-    touchesPayments: false,
-    touchesDatabase: false,
-    touchesAPI: false,
-    touchesUI: false,
-    touchesHealthData: false,
-    touchesSecurityConfig: false,
-    linesChanged: 50,
-    filePatterns: [],
-    framework: "unknown",
-    language: "typescript",
-    touchesCrypto: false,
-    touchesFileSystem: false,
-    touchesThirdPartyAPI: false,
-    touchesLogging: false,
-    touchesErrorHandling: false,
-    hasTests: false,
-    complexity: "medium",
-    patterns: {
-      hasAsyncCode: false,
-      hasFormHandling: false,
-      hasFileUploads: false,
-      hasEmailHandling: false,
-      hasRateLimiting: false,
-      hasWebSockets: false,
-      hasCaching: false,
-      hasQueue: false
-    }
-  };
-}
-function buildExplanation(result) {
-  const top = [...result.files].sort((a, b) => b.score - a.score)[0];
-  if (!top) return `Risk level ${result.overall} (no files provided)`;
-  return `Risk level ${result.overall} because ${top.file} ${top.reasons.join(", ")}`;
-}
-function buildRecommendation(risk, hasAntiPattern) {
-  if (hasAntiPattern || risk === "critical") {
-    return "Block until reviewed: address anti-patterns and rerun targeted tests.";
-  }
-  if (risk === "high") {
-    return "Require senior review and run full test suite before merge.";
-  }
-  if (risk === "medium") {
-    return "Proceed with caution; run impacted tests and sanity checks.";
-  }
-  return "Low risk; proceed but keep an eye on recent changes.";
-}
-async function reasonAboutChanges(projectPath, files, options = {}) {
-  const graph = new ContextGraph(projectPath);
-  const { matches, byFile } = await matchPatternsForFiles(graph, files);
-  const changeRisk = await scoreChangeSet(graph, files, byFile);
-  const incidents = [];
-  for (const file of files) {
-    const fileIncidents = await graph.getIncidentsForFile(file);
-    incidents.push(...fileIncidents);
-  }
-  const hasAntiPattern = matches.some((m) => m.isAntiPattern);
-  const riskLevel = hasAntiPattern ? "critical" : changeRisk.overall;
-  const shouldBlock = hasAntiPattern || riskLevel === "critical" || riskLevel === "high";
-  const reasoning = {
-    riskLevel,
-    shouldBlock,
-    explanation: buildExplanation(changeRisk),
-    relevantIncidents: incidents,
-    matchedPatterns: matches.map((m) => m.pattern),
-    recommendation: buildRecommendation(riskLevel, hasAntiPattern),
-    files: changeRisk.files
-  };
-  if (options.runAgents) {
-    const codeContext = options.codeContext ?? buildDefaultCodeContext();
-    const triager = new Triager();
-    const agents = await triager.triage(codeContext);
-    if (agents.length > 0) {
-      const executor = new Executor();
-      const scanContext = {
-        workingDir: projectPath,
-        ...options.scanContext
-      };
-      if (codeContext.framework) scanContext.framework = codeContext.framework;
-      if (codeContext.language) scanContext.language = codeContext.language;
-      reasoning.agentResults = await executor.executeAgents(agents, files, scanContext, {
-        parallel: true,
-        timeoutMs: options.scanContext?.config?.timeoutMs ?? 6e4
-      });
-    } else {
-      reasoning.agentResults = [];
-    }
-  }
-  return reasoning;
-}
-async function reasonAboutChangesHumanReadable(projectPath, files, options = {}) {
-  const reasoning = await reasonAboutChanges(projectPath, files, options);
-  const topFile = [...reasoning.files].sort((a, b) => b.score - a.score)[0];
-  const topReasons = topFile?.reasons?.slice(0, 3) ?? [];
-  const summaryParts = [];
-  summaryParts.push(`Risk ${reasoning.riskLevel.toUpperCase()} (${reasoning.shouldBlock ? "block" : "allow"})`);
-  if (topFile) summaryParts.push(`Most sensitive file: ${topFile.file}`);
-  if (topReasons.length) summaryParts.push(`Top reasons: ${topReasons.join("; ")}`);
-  const patterns = reasoning.matchedPatterns;
-  const incidents = reasoning.relevantIncidents;
-  const firstPattern = patterns[0];
-  const patternLine = firstPattern ? `Pattern match: ${firstPattern.data.description}` : "No known risky patterns matched.";
-  const incidentLine = incidents[0] ? `Relevant prior incident: ${incidents[0].data.description} (${incidents[0].data.severity})` : "No prior incidents linked to these files.";
-  const howBad = [
-    `Overall risk is ${reasoning.riskLevel}.`,
-    reasoning.shouldBlock ? "This is likely to break things or violate policy if pushed without review." : "This is unlikely to cause major issues if you follow normal review/testing.",
-    incidentLine
-  ].join(" ");
-  const whatToDo = [
-    reasoning.recommendation,
-    patterns.length ? `Double-check the pattern(s): ${patterns.slice(0, 2).map((p) => p.data.description).join(" | ")}.` : ""
-  ].filter(Boolean).join(" ");
-  return {
-    summary: summaryParts.join(" \u2014 "),
-    whatIFound: [patternLine, `Incidents considered: ${incidents.length}. Patterns considered: ${patterns.length}.`].join(" "),
-    howBad,
-    whatToDo,
-    original: reasoning
-  };
-}
-
-export {
-  formatFriendlyError,
-  LearningEngine,
-  perceiveCurrentChanges,
-  reasonAboutChangesHumanReadable,
-  isTrieInitialized
-};
-//# sourceMappingURL=chunk-YZ6Y2H3P.js.map