@triedotdev/mcp 1.0.168 → 1.0.170

package/dist/chunk-XTFWT2XM.js

@@ -1,727 +0,0 @@
-import {
-  getInsightStore
-} from "./chunk-T63OHG4Q.js";
-import {
-  searchIssues
-} from "./chunk-XE6KQRKZ.js";
-import {
-  getProjectState
-} from "./chunk-GTKYBOXL.js";
-
-// src/agent/hypothesis.ts
-import { dirname } from "path";
-var HYPOTHESIS_TEMPLATES = [
-  {
-    category: "timing",
-    statement: "Issues spike after weekend deployments",
-    testCriteria: "Compare Monday issue counts to other days",
-    minConfidence: 0.3,
-    dataRequired: ["issue_timestamps", "deployment_data"]
-  },
-  {
-    category: "timing",
-    statement: "Code quality declines on Fridays",
-    testCriteria: "Compare Friday issue introduction rate to weekly average",
-    minConfidence: 0.3,
-    dataRequired: ["issue_timestamps"]
-  },
-  {
-    category: "pattern",
-    statement: "Auth-related code has the highest incident rate",
-    testCriteria: "Compare auth/ issue count to other directories",
-    minConfidence: 0.4,
-    dataRequired: ["issue_files"]
-  },
-  {
-    category: "pattern",
-    statement: "Security issues cluster in specific directories",
-    testCriteria: "Check if security issues are concentrated (>50% in <3 dirs)",
-    minConfidence: 0.4,
-    dataRequired: ["issue_files", "issue_agents"]
-  },
-  {
-    category: "code",
-    statement: "Files with multiple authors have more issues",
-    testCriteria: "Correlate file author count with issue count",
-    minConfidence: 0.4,
-    dataRequired: ["issue_files", "git_blame"]
-  },
-  {
-    category: "code",
-    statement: "Recently modified files are more likely to have issues",
-    testCriteria: "Compare issue rate for recent vs old files",
-    minConfidence: 0.3,
-    dataRequired: ["issue_timestamps", "file_modification_times"]
-  },
-  {
-    category: "pattern",
-    statement: "Critical issues often come in clusters",
-    testCriteria: "Check temporal clustering of critical issues",
-    minConfidence: 0.3,
-    dataRequired: ["issue_timestamps", "issue_severities"]
-  }
-];
-var HypothesisEngine = class {
-  projectPath;
-  projectState;
-  insightStore;
-  constructor(projectPath) {
-    this.projectPath = projectPath;
-    this.projectState = getProjectState(projectPath);
-    this.insightStore = getInsightStore(projectPath);
-  }
-  /**
-   * Create a new hypothesis
-   */
-  async createHypothesis(statement, options) {
-    const hypothesis = {
-      id: `hyp-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-      statement,
-      confidence: options?.initialConfidence ?? 0,
-      status: "proposed",
-      evidence: [],
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      testCriteria: options?.testCriteria,
-      category: options?.category ?? "general",
-      autoGenerated: options?.autoGenerated ?? false
-    };
-    await this.projectState.addHypothesis(hypothesis);
-    return hypothesis;
-  }
-  /**
-   * Auto-generate hypotheses based on detected patterns
-   */
-  async autoGenerateHypotheses() {
-    const generated = [];
-    try {
-      await this.projectState.load();
-      const existing = this.projectState.getAllHypotheses();
-      const existingStatements = new Set(existing.map((h) => h.statement.toLowerCase()));
-      const issues = await searchIssues("", {
-        workDir: this.projectPath,
-        limit: 500,
-        includeResolved: true
-      });
-      if (issues.length < 10) {
-        return generated;
-      }
-      for (const template of HYPOTHESIS_TEMPLATES) {
-        if (existingStatements.has(template.statement.toLowerCase())) {
-          continue;
-        }
-        const evidence = await this.gatherInitialEvidence(template, issues);
-        if (evidence.length > 0 && evidence[0].weight >= template.minConfidence) {
-          const hypothesis = await this.createHypothesis(template.statement, {
-            category: template.category,
-            testCriteria: template.testCriteria,
-            initialConfidence: evidence[0].weight,
-            autoGenerated: true
-          });
-          for (const e of evidence) {
-            await this.projectState.addEvidence(hypothesis.id, e);
-          }
-          generated.push(hypothesis);
-          if (generated.length >= 4) break;
-        }
-      }
-    } catch (error) {
-    }
-    return generated;
-  }
-  /**
-   * Use Claude AI to generate novel hypotheses from observed patterns
-   * This enables fully agentic hypothesis creation based on actual codebase observations
-   */
-  async generateHypothesesWithAI(context) {
-    const { isAIAvailable, runAIAnalysis } = await import("./client-NJPZE5JT.js");
-    if (!isAIAvailable()) {
-      return [];
-    }
-    const generated = [];
-    try {
-      await this.projectState.load();
-      const existing = this.projectState.getAllHypotheses();
-      const existingStatements = existing.map((h) => h.statement);
-      const issues = context.recentIssues || await searchIssues("", {
-        workDir: this.projectPath,
-        limit: 100,
-        includeResolved: true
-      });
-      if (issues.length < 5) {
-        return generated;
-      }
-      const issuesSummary = this.summarizeIssuesForAI(issues);
-      const patternsSummary = context.patterns?.join("\n") || "No explicit patterns provided";
-      const observationsSummary = context.observations?.join("\n") || "No explicit observations provided";
-      const prompt = `You are an AI agent observing a codebase over time. Based on the patterns below, generate 1-3 testable hypotheses about this codebase's quality patterns.
-
-## Recent Issues Summary
-${issuesSummary}
-
-## Observed Patterns
-${patternsSummary}
-
-## Additional Observations
-${observationsSummary}
-
-## Existing Hypotheses (avoid duplicates)
-${existingStatements.length > 0 ? existingStatements.map((s) => `- ${s}`).join("\n") : "None yet"}
-
-Generate hypotheses that are:
-1. Specific and testable (can be validated with data)
-2. Actionable (if validated, can guide improvements)
-3. Novel (not duplicates of existing hypotheses)
-4. Based on real patterns in the data above
-
-Return ONLY a JSON array of hypotheses. Each hypothesis must have:
-- "statement": Clear, concise hypothesis statement
-- "category": One of: "timing", "pattern", "team", "code", "general"
-- "testCriteria": How to test this hypothesis
-- "confidence": Initial confidence (0-1)
-- "reasoning": Why you think this hypothesis is worth testing
-
-Example format:
-[
-  {
-    "statement": "Authentication code changes correlate with security issues",
-    "category": "pattern",
-    "testCriteria": "Track auth file changes and subsequent security issue rates",
-    "confidence": 0.6,
-    "reasoning": "65% of security issues occur in files modified in the past week"
-  }
-]
-
-Return empty array [] if no novel hypotheses can be generated from the data.`;
-      const result = await runAIAnalysis({
-        systemPrompt: "You are an expert code quality analyst who identifies patterns and generates testable hypotheses.",
-        userPrompt: prompt,
-        maxTokens: 2048,
-        // Increased to prevent truncation of hypothesis generation
-        temperature: 0.7
-        // Higher temperature for creative hypothesis generation
-      });
-      if (!result.success || !result.content.trim()) {
-        return generated;
-      }
-      let aiHypotheses = [];
-      try {
-        const cleaned = result.content.replace(/```json?\n?|\n?```/g, "").trim();
-        aiHypotheses = JSON.parse(cleaned);
-        if (!Array.isArray(aiHypotheses)) aiHypotheses = [];
-      } catch {
-        return generated;
-      }
-      for (const aiHypo of aiHypotheses.slice(0, 5)) {
-        const isDuplicate = existingStatements.some(
-          (existing2) => existing2.toLowerCase() === aiHypo.statement.toLowerCase() || existing2.toLowerCase().includes(aiHypo.statement.toLowerCase()) || aiHypo.statement.toLowerCase().includes(existing2.toLowerCase())
-        );
-        if (isDuplicate) continue;
-        const hypothesis = await this.createHypothesis(aiHypo.statement, {
-          category: aiHypo.category,
-          testCriteria: aiHypo.testCriteria,
-          initialConfidence: Math.max(0.3, Math.min(0.7, aiHypo.confidence)),
-          autoGenerated: true
-        });
-        await this.projectState.addEvidence(hypothesis.id, {
-          type: "supporting",
-          description: `AI observed: ${aiHypo.reasoning}`,
-          weight: aiHypo.confidence
-        });
-        generated.push(hypothesis);
-      }
-    } catch (error) {
-    }
-    return generated;
-  }
-  /**
-   * Summarize issues for AI context
-   */
-  summarizeIssuesForAI(issues) {
-    const totalIssues = issues.length;
-    const severityCounts = {};
-    for (const { issue } of issues) {
-      severityCounts[issue.severity] = (severityCounts[issue.severity] || 0) + 1;
-    }
-    const agentCounts = {};
-    for (const { issue } of issues) {
-      agentCounts[issue.agent] = (agentCounts[issue.agent] || 0) + 1;
-    }
-    const fileCounts = {};
-    for (const { issue } of issues) {
-      const dir = dirname(issue.file);
-      fileCounts[dir] = (fileCounts[dir] || 0) + 1;
-    }
-    const dayOfWeekCounts = {};
-    for (const { issue } of issues) {
-      const date = new Date(issue.timestamp);
-      const day = date.getDay();
-      dayOfWeekCounts[day] = (dayOfWeekCounts[day] || 0) + 1;
-    }
-    const dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
-    const dayDistribution = Object.entries(dayOfWeekCounts).sort(([a], [b]) => Number(a) - Number(b)).map(([day, count]) => `${dayNames[Number(day)]}: ${count}`).join(", ");
-    const topDirs = Object.entries(fileCounts).sort(([, a], [, b]) => b - a).slice(0, 8).map(([dir, count]) => `${dir}: ${count}`).join(", ");
-    const topAgents = Object.entries(agentCounts).sort(([, a], [, b]) => b - a).slice(0, 8).map(([agent, count]) => `${agent}: ${count}`).join(", ");
-    return `Total Issues: ${totalIssues}
-Severities: ${Object.entries(severityCounts).map(([s, c]) => `${s}=${c}`).join(", ")}
-Top Agents: ${topAgents}
-Top Directories: ${topDirs}
-Day Distribution: ${dayDistribution}`;
-  }
-  /**
-   * Gather initial evidence for a hypothesis template
-   */
-  async gatherInitialEvidence(template, issues) {
-    const evidence = [];
-    switch (template.category) {
-      case "timing":
-        evidence.push(...this.analyzeTimingPatterns(template, issues));
-        break;
-      case "pattern":
-        evidence.push(...this.analyzeLocationPatterns(template, issues));
-        break;
-      case "code":
-        evidence.push(...this.analyzeCodePatterns(template, issues));
-        break;
-    }
-    return evidence;
-  }
-  /**
-   * Analyze timing patterns in issues
-   */
-  analyzeTimingPatterns(template, issues) {
-    const evidence = [];
-    const dayOfWeekCounts = {};
-    for (const { issue } of issues) {
-      const date = new Date(issue.timestamp);
-      const day = date.getDay();
-      dayOfWeekCounts[day] = (dayOfWeekCounts[day] || 0) + 1;
-    }
-    if (template.statement.includes("Friday")) {
-      const fridayCount = dayOfWeekCounts[5] || 0;
-      const avgOtherDays = (Object.values(dayOfWeekCounts).reduce((a, b) => a + b, 0) - fridayCount) / 4;
-      if (fridayCount > avgOtherDays * 1.5) {
-        evidence.push({
-          type: "supporting",
-          description: `Friday has ${((fridayCount / avgOtherDays - 1) * 100).toFixed(0)}% more issues than average`,
-          weight: Math.min(0.8, 0.3 + (fridayCount / avgOtherDays - 1) * 0.2),
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      } else {
-        evidence.push({
-          type: "contradicting",
-          description: "Friday issue count is not significantly higher",
-          weight: 0.3,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      }
-    }
-    if (template.statement.includes("weekend") || template.statement.includes("Monday")) {
-      const mondayCount = dayOfWeekCounts[1] || 0;
-      const avgOtherDays = (Object.values(dayOfWeekCounts).reduce((a, b) => a + b, 0) - mondayCount) / 4;
-      if (mondayCount > avgOtherDays * 1.5) {
-        evidence.push({
-          type: "supporting",
-          description: `Monday has ${((mondayCount / avgOtherDays - 1) * 100).toFixed(0)}% more issues than average`,
-          weight: Math.min(0.8, 0.3 + (mondayCount / avgOtherDays - 1) * 0.2),
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      }
-    }
-    return evidence;
-  }
-  /**
-   * Analyze location patterns in issues
-   */
-  analyzeLocationPatterns(template, issues) {
-    const evidence = [];
-    const dirCounts = {};
-    for (const { issue } of issues) {
-      const dir = dirname(issue.file);
-      dirCounts[dir] = (dirCounts[dir] || 0) + 1;
-    }
-    const sortedDirs = Object.entries(dirCounts).sort(([, a], [, b]) => b - a);
-    if (template.statement.includes("Auth")) {
-      const authDirs = sortedDirs.filter(
-        ([dir]) => dir.toLowerCase().includes("auth") || dir.toLowerCase().includes("login") || dir.toLowerCase().includes("session")
-      );
-      const authCount = authDirs.reduce((sum, [, count]) => sum + count, 0);
-      const percentage = authCount / issues.length * 100;
-      if (percentage >= 20) {
-        evidence.push({
-          type: "supporting",
-          description: `Auth-related code has ${percentage.toFixed(0)}% of issues`,
-          weight: Math.min(0.85, 0.4 + percentage / 100),
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      }
-    }
-    if (template.statement.includes("cluster")) {
-      const topThreeDirs = sortedDirs.slice(0, 3);
-      const topThreeCount = topThreeDirs.reduce((sum, [, count]) => sum + count, 0);
-      const percentage = topThreeCount / issues.length * 100;
-      if (percentage >= 50) {
-        evidence.push({
-          type: "supporting",
-          description: `Top 3 directories have ${percentage.toFixed(0)}% of issues`,
-          weight: Math.min(0.8, 0.3 + percentage / 100),
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      }
-    }
-    return evidence;
-  }
-  /**
-   * Analyze code patterns
-   */
-  analyzeCodePatterns(template, issues) {
-    const evidence = [];
-    if (template.statement.includes("cluster")) {
-      const criticalIssues = issues.filter((r) => r.issue.severity === "critical");
-      if (criticalIssues.length >= 3) {
-        const timestamps = criticalIssues.map((r) => new Date(r.issue.timestamp).getTime()).sort((a, b) => a - b);
-        let clusteredCount = 0;
-        for (let i = 1; i < timestamps.length; i++) {
-          if (timestamps[i] - timestamps[i - 1] < 24 * 60 * 60 * 1e3) {
-            clusteredCount++;
-          }
-        }
-        const clusterRatio = clusteredCount / (timestamps.length - 1);
-        if (clusterRatio >= 0.5) {
-          evidence.push({
-            type: "supporting",
-            description: `${(clusterRatio * 100).toFixed(0)}% of critical issues occur within 24h of another`,
-            weight: Math.min(0.75, 0.3 + clusterRatio * 0.4),
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          });
-        }
-      }
-    }
-    return evidence;
-  }
-  /**
-   * Update confidence scores based on new data
-   */
-  async updateConfidenceFromOutcomes() {
-    const analyses = [];
-    try {
-      await this.projectState.load();
-      const activeHypotheses = this.projectState.getActiveHypotheses();
-      for (const hypothesis of activeHypotheses) {
-        const analysis = await this.analyzeHypothesis(hypothesis);
-        analyses.push(analysis);
-        if (analysis.statusChange && this.insightStore.canCreateInsight("hypothesis-update")) {
-          const insight = this.createHypothesisInsight(analysis);
-          await this.insightStore.addInsight(insight);
-          await this.insightStore.markInsightCreated("hypothesis-update");
-        }
-      }
-      await this.projectState.updateHypothesisAccuracy();
-    } catch (error) {
-    }
-    return analyses;
-  }
-  /**
-   * Analyze a single hypothesis
-   */
-  async analyzeHypothesis(hypothesis, signal) {
-    if (signal?.aborted) throw new DOMException("Scan cancelled", "AbortError");
-    const issues = await searchIssues("", {
-      workDir: this.projectPath,
-      limit: 100,
-      includeResolved: false
-    });
-    if (signal?.aborted) throw new DOMException("Scan cancelled", "AbortError");
-    const template = HYPOTHESIS_TEMPLATES.find(
-      (t) => t.statement.toLowerCase() === hypothesis.statement.toLowerCase()
-    );
-    const recentEvidence = [];
-    if (template) {
-      recentEvidence.push(...await this.gatherInitialEvidence(template, issues));
-    } else {
-      recentEvidence.push(...this.gatherSemanticEvidence(hypothesis, issues));
-    }
-    const oldConfidence = hypothesis.confidence;
-    let newConfidence = oldConfidence;
-    for (const evidence of recentEvidence) {
-      if (evidence.type === "supporting") {
-        newConfidence = Math.min(1, newConfidence + evidence.weight * 0.1);
-      } else {
-        newConfidence = Math.max(0, newConfidence - evidence.weight * 0.1);
-      }
-    }
-    let statusChange;
-    if (signal?.aborted) throw new DOMException("Scan cancelled", "AbortError");
-    if (newConfidence >= 0.8 && hypothesis.evidence.length >= 3) {
-      statusChange = "validated";
-      await this.projectState.updateHypothesis(hypothesis.id, {
-        status: "validated",
-        confidence: newConfidence,
-        validatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    } else if (newConfidence <= 0.2 && hypothesis.evidence.length >= 3) {
-      statusChange = "invalidated";
-      await this.projectState.updateHypothesis(hypothesis.id, {
-        status: "invalidated",
-        confidence: newConfidence
-      });
-    } else {
-      await this.projectState.updateHypothesis(hypothesis.id, {
-        confidence: newConfidence
-      });
-    }
-    for (const evidence of recentEvidence) {
-      await this.projectState.addEvidence(hypothesis.id, evidence);
-    }
-    const analysis = {
-      hypothesis: { ...hypothesis, confidence: newConfidence },
-      recentEvidence,
-      confidenceChange: newConfidence - oldConfidence,
-      actionRequired: statusChange !== void 0
-    };
-    if (statusChange) {
-      analysis.statusChange = statusChange;
-    }
-    return analysis;
-  }
-  /**
-   * Gather evidence for user-created hypotheses using semantic matching
-   * 
-   * This enables agentic tracking for natural language hypotheses like:
-   * - "Mondays have more bugs than Fridays"
-   * - "Code reviews reduce bug rate"
-   * - "Security issues cluster in auth code"
-   */
-  gatherSemanticEvidence(hypothesis, issues) {
-    const evidence = [];
-    const stmt = hypothesis.statement.toLowerCase();
-    if (stmt.includes("monday") || stmt.includes("friday") || stmt.includes("weekend") || stmt.includes("morning") || stmt.includes("afternoon")) {
-      const dayNames = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
-      const dayOfWeekCounts = { 0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0 };
-      for (const { issue } of issues) {
-        const date = new Date(issue.timestamp);
-        const day = date.getDay();
-        dayOfWeekCounts[day] = (dayOfWeekCounts[day] || 0) + 1;
-      }
-      const totalIssues = Object.values(dayOfWeekCounts).reduce((a, b) => a + b, 0);
-      const avgPerDay = totalIssues / 7;
-      for (let dayIdx = 0; dayIdx < 7; dayIdx++) {
-        const dayName = dayNames[dayIdx];
-        if (stmt.includes(dayName)) {
-          const dayCount = dayOfWeekCounts[dayIdx] || 0;
-          if (stmt.includes("more") || stmt.includes("higher") || stmt.includes("spike")) {
-            if (dayCount > avgPerDay * 1.3) {
-              evidence.push({
-                type: "supporting",
-                description: `${dayName.charAt(0).toUpperCase() + dayName.slice(1)} has ${dayCount} issues (${((dayCount / avgPerDay - 1) * 100).toFixed(0)}% above average)`,
-                weight: Math.min(0.7, 0.3 + (dayCount / avgPerDay - 1) * 0.3),
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              });
-            } else {
-              evidence.push({
-                type: "contradicting",
-                description: `${dayName.charAt(0).toUpperCase() + dayName.slice(1)} has average or below average issue count`,
-                weight: 0.3,
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              });
-            }
-          } else if (stmt.includes("fewer") || stmt.includes("less") || stmt.includes("reduce")) {
-            if (dayCount < avgPerDay * 0.7) {
-              evidence.push({
-                type: "supporting",
-                description: `${dayName.charAt(0).toUpperCase() + dayName.slice(1)} has ${dayCount} issues (${((1 - dayCount / avgPerDay) * 100).toFixed(0)}% below average)`,
-                weight: Math.min(0.7, 0.3 + (1 - dayCount / avgPerDay) * 0.3),
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              });
-            }
-          }
-        }
-      }
-    }
-    if (stmt.includes("review") || stmt.includes("pr") || stmt.includes("pull request")) {
-      const recentIssues = issues.slice(0, 30);
-      const olderIssues = issues.slice(30);
-      if (recentIssues.length >= 10 && olderIssues.length >= 10) {
-        const recentRate = recentIssues.length;
-        const olderRate = olderIssues.length;
-        if (stmt.includes("reduce") || stmt.includes("fewer") || stmt.includes("less")) {
-          if (recentRate < olderRate) {
-            evidence.push({
-              type: "supporting",
-              description: `Recent period has ${((1 - recentRate / olderRate) * 100).toFixed(0)}% fewer issues`,
-              weight: Math.min(0.6, 0.3 + (1 - recentRate / olderRate) * 0.3),
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
-          } else {
-            evidence.push({
-              type: "contradicting",
-              description: `Issue rate has not decreased recently`,
-              weight: 0.2,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
-          }
-        }
-      }
-    }
-    if (stmt.includes("cluster") || stmt.includes("concentrate") || stmt.includes("auth") || stmt.includes("specific") || stmt.includes("certain files")) {
-      const dirCounts = {};
-      for (const { issue } of issues) {
-        const dir = dirname(issue.file);
-        dirCounts[dir] = (dirCounts[dir] || 0) + 1;
-      }
-      const sortedDirs = Object.entries(dirCounts).sort(([, a], [, b]) => b - a);
-      const topThreeCount = sortedDirs.slice(0, 3).reduce((sum, [, count]) => sum + count, 0);
-      const totalCount = issues.length;
-      const concentration = topThreeCount / totalCount;
-      if (concentration >= 0.5) {
-        evidence.push({
-          type: "supporting",
-          description: `Top 3 directories have ${(concentration * 100).toFixed(0)}% of issues (concentrated)`,
-          weight: Math.min(0.7, 0.3 + concentration * 0.4),
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      } else {
-        evidence.push({
-          type: "contradicting",
-          description: `Issues are distributed across many directories`,
-          weight: 0.3,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      }
-    }
-    if (stmt.includes("critical") || stmt.includes("security") || stmt.includes("severity")) {
-      const criticalCount = issues.filter((r) => r.issue.severity === "critical").length;
-      const seriousCount = issues.filter((r) => r.issue.severity === "serious").length;
-      const highSeverityRatio = (criticalCount + seriousCount) / issues.length;
-      if (stmt.includes("increase") || stmt.includes("more") || stmt.includes("rise")) {
-        if (highSeverityRatio > 0.3) {
-          evidence.push({
-            type: "supporting",
-            description: `${(highSeverityRatio * 100).toFixed(0)}% of issues are high severity`,
-            weight: Math.min(0.7, 0.3 + highSeverityRatio),
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          });
-        }
-      } else if (stmt.includes("decrease") || stmt.includes("fewer") || stmt.includes("reduce")) {
-        if (highSeverityRatio < 0.2) {
-          evidence.push({
-            type: "supporting",
-            description: `Only ${(highSeverityRatio * 100).toFixed(0)}% of issues are high severity`,
-            weight: 0.5,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          });
-        }
-      }
-    }
-    const agents = ["security", "performance", "accessibility", "test", "typecheck", "bug-finding"];
-    for (const agent of agents) {
-      if (stmt.includes(agent) || stmt.includes(agent.replace("-", " "))) {
-        const agentIssues = issues.filter((r) => r.issue.agent === agent);
-        const agentRatio = agentIssues.length / issues.length;
-        if (stmt.includes("most") || stmt.includes("majority") || stmt.includes("main")) {
-          if (agentRatio > 0.4) {
-            evidence.push({
-              type: "supporting",
-              description: `${agent} accounts for ${(agentRatio * 100).toFixed(0)}% of issues`,
-              weight: Math.min(0.7, 0.3 + agentRatio),
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
-          } else {
-            evidence.push({
-              type: "contradicting",
-              description: `${agent} only accounts for ${(agentRatio * 100).toFixed(0)}% of issues`,
-              weight: 0.3,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
-          }
-        }
-      }
-    }
-    return evidence;
-  }
-  /**
-   * Create an insight for hypothesis status change
-   */
-  createHypothesisInsight(analysis) {
-    const isValidated = analysis.statusChange === "validated";
-    return {
-      id: `insight-hyp-${analysis.hypothesis.id}`,
-      type: isValidated ? "celebration" : "observation",
-      message: isValidated ? `Hypothesis confirmed: "${analysis.hypothesis.statement}"` : `Hypothesis disproven: "${analysis.hypothesis.statement}"`,
-      context: `Confidence: ${(analysis.hypothesis.confidence * 100).toFixed(0)}%. ${analysis.recentEvidence.length} evidence points analyzed.`,
-      relatedIssues: [],
-      priority: 5,
-      timestamp: Date.now(),
-      dismissed: false,
-      category: "pattern",
-      details: {
-        examples: analysis.recentEvidence.map((e) => `${e.type}: ${e.description}`)
-      }
-    };
-  }
-  /**
-   * Get hypothesis by ID
-   */
-  async getHypothesis(hypothesisId) {
-    await this.projectState.load();
-    return this.projectState.getHypothesis(hypothesisId);
-  }
-  /**
-   * Get all hypotheses
-   */
-  async getAllHypotheses() {
-    await this.projectState.load();
-    return this.projectState.getAllHypotheses();
-  }
-  /**
-   * Get validated hypotheses
-   */
-  async getValidatedHypotheses() {
-    await this.projectState.load();
-    return this.projectState.getValidatedHypotheses();
-  }
-  /**
-   * Get hypothesis accuracy stats
-   */
-  getAccuracy() {
-    const metrics = this.projectState.getMetrics();
-    return metrics.hypothesisAccuracy;
-  }
-};
-var hypothesisEngines = /* @__PURE__ */ new Map();
-function getHypothesisEngine(projectPath) {
-  let engine = hypothesisEngines.get(projectPath);
-  if (!engine) {
-    engine = new HypothesisEngine(projectPath);
-    hypothesisEngines.set(projectPath, engine);
-  }
-  return engine;
-}
-function clearHypothesisEngines() {
-  hypothesisEngines.clear();
-}
-async function gatherEvidenceForHypothesis(hypothesisId, projectPath, signal) {
-  if (signal?.aborted) throw new DOMException("Scan cancelled", "AbortError");
-  const engine = getHypothesisEngine(projectPath);
-  const projectState = getProjectState(projectPath);
-  await projectState.load();
-  if (signal?.aborted) throw new DOMException("Scan cancelled", "AbortError");
-  const hypothesis = projectState.getAllHypotheses().find((h) => h.id === hypothesisId);
-  if (!hypothesis) {
-    throw new Error(`Hypothesis ${hypothesisId} not found`);
-  }
-  const analysis = await engine.analyzeHypothesis(hypothesis, signal);
-  return analysis.recentEvidence.map((e) => ({
-    supports: e.type === "supporting",
-    description: e.description,
-    weight: e.weight
-  }));
-}
-
-export {
-  HypothesisEngine,
-  getHypothesisEngine,
-  clearHypothesisEngines,
-  gatherEvidenceForHypothesis
-};
-//# sourceMappingURL=chunk-XTFWT2XM.js.map