@triedotdev/mcp 1.0.113 → 1.0.115

package/dist/chunk-DZREHOGW.js

@@ -0,0 +1,706 @@
+import {
+  getInsightStore
+} from "./chunk-6LXSA2OZ.js";
+import {
+  searchIssues
+} from "./chunk-55DOQNHJ.js";
+import {
+  getGuardianState
+} from "./chunk-KRH642MT.js";
+
+// src/guardian/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;
+  guardianState;
+  insightStore;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.guardianState = getGuardianState(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.5,
+      status: "proposed",
+      evidence: [],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      testCriteria: options?.testCriteria,
+      category: options?.category ?? "general"
+    };
+    await this.guardianState.addHypothesis(hypothesis);
+    return hypothesis;
+  }
+  /**
+   * Auto-generate hypotheses based on detected patterns
+   */
+  async autoGenerateHypotheses() {
+    const generated = [];
+    try {
+      await this.guardianState.load();
+      const existing = this.guardianState.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
+          });
+          for (const e of evidence) {
+            await this.guardianState.addEvidence(hypothesis.id, e);
+          }
+          generated.push(hypothesis);
+          if (generated.length >= 2) break;
+        }
+      }
+    } catch (error) {
+      console.error("Failed to auto-generate hypotheses:", 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-7XZHCMD3.js");
+    if (!isAIAvailable()) {
+      return [];
+    }
+    const generated = [];
+    try {
+      await this.guardianState.load();
+      const existing = this.guardianState.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: 1024,
+        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, 3)) {
+        const isDuplicate = existingStatements.some(
+          (existing2) => existing2.toLowerCase().includes(aiHypo.statement.toLowerCase().slice(0, 30))
+        );
+        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))
+        });
+        await this.guardianState.addEvidence(hypothesis.id, {
+          type: "supporting",
+          description: `AI observed: ${aiHypo.reasoning}`,
+          weight: aiHypo.confidence,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        generated.push(hypothesis);
+      }
+    } catch (error) {
+      console.error("Failed to generate hypotheses with AI:", 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, 5).map(([dir, count]) => `${dir}: ${count}`).join(", ");
+    const topAgents = Object.entries(agentCounts).sort(([, a], [, b]) => b - a).slice(0, 5).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.guardianState.load();
+      const activeHypotheses = this.guardianState.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.guardianState.updateHypothesisAccuracy();
+    } catch (error) {
+      console.error("Failed to update hypothesis confidence:", error);
+    }
+    return analyses;
+  }
+  /**
+   * Analyze a single hypothesis
+   */
+  async analyzeHypothesis(hypothesis) {
+    const issues = await searchIssues("", {
+      workDir: this.projectPath,
+      limit: 100,
+      includeResolved: false
+    });
+    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 (newConfidence >= 0.8 && hypothesis.evidence.length >= 3) {
+      statusChange = "validated";
+      await this.guardianState.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.guardianState.updateHypothesis(hypothesis.id, {
+        status: "invalidated",
+        confidence: newConfidence
+      });
+    } else {
+      await this.guardianState.updateHypothesis(hypothesis.id, {
+        confidence: newConfidence
+      });
+    }
+    for (const evidence of recentEvidence) {
+      await this.guardianState.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.guardianState.load();
+    return this.guardianState.getHypothesis(hypothesisId);
+  }
+  /**
+   * Get all hypotheses
+   */
+  async getAllHypotheses() {
+    await this.guardianState.load();
+    return this.guardianState.getAllHypotheses();
+  }
+  /**
+   * Get validated hypotheses
+   */
+  async getValidatedHypotheses() {
+    await this.guardianState.load();
+    return this.guardianState.getValidatedHypotheses();
+  }
+  /**
+   * Get hypothesis accuracy stats
+   */
+  getAccuracy() {
+    const metrics = this.guardianState.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();
+}
+
+export {
+  HypothesisEngine,
+  getHypothesisEngine,
+  clearHypothesisEngines
+};
+//# sourceMappingURL=chunk-DZREHOGW.js.map