@triedotdev/mcp 1.0.61 → 1.0.63

package/dist/chunk-D3DMONAJ.js

@@ -0,0 +1,904 @@
+import {
+  getGuardianState
+} from "./chunk-4YSLDGBL.js";
+import {
+  BackupManager,
+  atomicWriteJSON,
+  getMemoryStats,
+  safeParseAndValidate,
+  searchIssues
+} from "./chunk-TSHZQKCM.js";
+
+// src/guardian/insight-store.ts
+import { mkdir, readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { z } from "zod";
+var InsightDetailsSchema = z.object({
+  affectedFiles: z.array(z.string()).optional(),
+  issueBreakdown: z.record(z.string(), z.number()).optional(),
+  examples: z.array(z.string()).optional(),
+  trend: z.enum(["improving", "stable", "worsening"]).optional(),
+  comparison: z.string().optional()
+});
+var GuardianInsightSchema = z.object({
+  id: z.string(),
+  type: z.enum(["observation", "warning", "suggestion", "celebration", "question"]),
+  message: z.string(),
+  context: z.string().optional(),
+  suggestedAction: z.string().optional(),
+  actionCommand: z.string().optional(),
+  relatedIssues: z.array(z.string()),
+  priority: z.number().min(1).max(10),
+  timestamp: z.number(),
+  dismissed: z.boolean(),
+  category: z.enum(["security", "quality", "performance", "pattern", "progress", "general"]),
+  details: InsightDetailsSchema.optional()
+});
+var InsightStoreDataSchema = z.object({
+  version: z.literal(1),
+  insights: z.array(GuardianInsightSchema),
+  cooldowns: z.record(z.string(), z.number()),
+  // insightKey -> timestamp
+  dismissedIds: z.array(z.string()),
+  // Track dismissed insight IDs permanently
+  lastUpdated: z.string()
+});
+var InsightStore = class _InsightStore {
+  projectPath;
+  data;
+  loaded = false;
+  dirty = false;
+  // Default cooldown periods (in ms)
+  static COOLDOWNS = {
+    "pre-push-warning": 6e4,
+    // 1 min between pre-push warnings
+    "security-warning": 3e4,
+    // 30s between security warnings
+    "new-issues": 3e4,
+    // 30s between new issue observations
+    "celebration": 6e4,
+    // 1 min between celebrations
+    "pattern-suggestion": 12e4,
+    // 2 min between pattern suggestions
+    "accessibility-visual-qa": 3e5,
+    // 5 min between visual QA suggestions
+    "goal-suggestion": 3e5,
+    // 5 min between goal suggestions
+    "risk-prediction": 18e4,
+    // 3 min between risk predictions
+    "hypothesis-update": 6e5,
+    // 10 min between hypothesis updates
+    "auto-escalation": 3e5
+    // 5 min between auto-escalations
+  };
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.data = this.createEmptyData();
+  }
+  /**
+   * Get the storage file path
+   */
+  getStorePath() {
+    return join(this.projectPath, ".trie", "memory", "guardian-insights.json");
+  }
+  /**
+   * Create empty data structure
+   */
+  createEmptyData() {
+    return {
+      version: 1,
+      insights: [],
+      cooldowns: {},
+      dismissedIds: [],
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Load insights from disk
+   * 
+   * If the file is corrupted, attempts recovery from backup.
+   * Returns empty data if no valid file/backup exists.
+   */
+  async load() {
+    if (this.loaded) {
+      return this.data;
+    }
+    const storePath = this.getStorePath();
+    try {
+      if (existsSync(storePath)) {
+        const content = await readFile(storePath, "utf-8");
+        const result = safeParseAndValidate(content, InsightStoreDataSchema);
+        if (result.success) {
+          this.data = result.data;
+          this.loaded = true;
+          this.deduplicateInsights();
+          return this.data;
+        }
+        console.error(`   \u26A0\uFE0F Insight store corrupted: ${result.error}`);
+        const backupManager = new BackupManager(storePath);
+        if (await backupManager.recoverFromBackup()) {
+          console.error("   \u2705 Recovered from backup");
+          const recovered = await readFile(storePath, "utf-8");
+          const recoveredResult = safeParseAndValidate(recovered, InsightStoreDataSchema);
+          if (recoveredResult.success) {
+            this.data = recoveredResult.data;
+            this.loaded = true;
+            this.deduplicateInsights();
+            return this.data;
+          }
+        }
+        console.error("   \u274C No valid backup found, starting fresh");
+      }
+    } catch (error) {
+      console.error(`   \u26A0\uFE0F Could not load insight store: ${error}`);
+    }
+    this.data = this.createEmptyData();
+    this.loaded = true;
+    return this.data;
+  }
+  /**
+   * Deduplicate existing insights on load
+   * Keeps the most recent instance of each unique insight
+   */
+  deduplicateInsights() {
+    const seen = /* @__PURE__ */ new Map();
+    const toRemove = [];
+    for (let i = 0; i < this.data.insights.length; i++) {
+      const insight = this.data.insights[i];
+      if (!insight) continue;
+      const contentKey = this.getContentKey(insight);
+      if (seen.has(contentKey)) {
+        toRemove.push(i);
+      } else {
+        seen.set(contentKey, i);
+      }
+    }
+    if (toRemove.length > 0) {
+      for (let i = toRemove.length - 1; i >= 0; i--) {
+        const idx = toRemove[i];
+        if (idx !== void 0) {
+          this.data.insights.splice(idx, 1);
+        }
+      }
+      this.dirty = true;
+    }
+  }
+  /**
+   * Save insights to disk
+   * 
+   * Creates backup before writing, uses atomic write.
+   */
+  async save() {
+    if (!this.dirty && this.loaded) {
+      return;
+    }
+    const storePath = this.getStorePath();
+    const memoryDir = join(this.projectPath, ".trie", "memory");
+    await mkdir(memoryDir, { recursive: true });
+    const backupManager = new BackupManager(storePath);
+    await backupManager.createBackup();
+    this.data.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    await atomicWriteJSON(storePath, this.data);
+    this.dirty = false;
+  }
+  /**
+   * Generate a content-based key for deduplication
+   * Insights with the same content key are considered duplicates
+   */
+  getContentKey(insight) {
+    const normalizedMessage = insight.message.replace(/\d+/g, "N").toLowerCase().trim();
+    return `${insight.type}:${insight.category}:${normalizedMessage}`;
+  }
+  /**
+   * Add an insight to the store
+   * 
+   * Checks for duplicates using both insight ID and content similarity.
+   * If a similar insight already exists (same type, category, and normalized message),
+   * updates its timestamp instead of creating a duplicate.
+   * Respects cooldowns to prevent insight spam.
+   */
+  async addInsight(insight) {
+    await this.load();
+    if (this.data.insights.some((i) => i.id === insight.id)) {
+      return false;
+    }
+    if (this.data.dismissedIds.includes(insight.id)) {
+      return false;
+    }
+    const contentKey = this.getContentKey(insight);
+    const existingIndex = this.data.insights.findIndex(
+      (i) => !i.dismissed && this.getContentKey(i) === contentKey
+    );
+    if (existingIndex >= 0) {
+      const existing = this.data.insights[existingIndex];
+      if (existing) {
+        existing.timestamp = insight.timestamp;
+        existing.message = insight.message;
+        existing.details = insight.details;
+        existing.relatedIssues = insight.relatedIssues;
+        existing.suggestedAction = insight.suggestedAction;
+        this.data.insights.splice(existingIndex, 1);
+        this.data.insights.unshift(existing);
+        this.dirty = true;
+        await this.save();
+      }
+      return false;
+    }
+    this.data.insights.unshift(insight);
+    if (this.data.insights.length > 100) {
+      this.data.insights = this.data.insights.slice(0, 100);
+    }
+    this.dirty = true;
+    await this.save();
+    return true;
+  }
+  /**
+   * Check if a cooldown has expired for an insight type
+   */
+  canCreateInsight(insightKey) {
+    const lastTime = this.data.cooldowns[insightKey];
+    const cooldown = _InsightStore.COOLDOWNS[insightKey] || 3e4;
+    if (!lastTime) return true;
+    return Date.now() - lastTime > cooldown;
+  }
+  /**
+   * Mark that an insight type was created (set cooldown)
+   */
+  async markInsightCreated(insightKey) {
+    await this.load();
+    this.data.cooldowns[insightKey] = Date.now();
+    this.dirty = true;
+    await this.save();
+  }
+  /**
+   * Get active (non-dismissed) insights
+   * 
+   * Returns insights sorted by priority (highest first),
+   * limited to the specified count.
+   */
+  getActiveInsights(limit = 5) {
+    return this.data.insights.filter((i) => !i.dismissed).sort((a, b) => b.priority - a.priority).slice(0, limit);
+  }
+  /**
+   * Get all insights (including dismissed)
+   */
+  getAllInsights() {
+    return [...this.data.insights];
+  }
+  /**
+   * Dismiss an insight by ID
+   */
+  async dismissInsight(insightId) {
+    await this.load();
+    const insight = this.data.insights.find((i) => i.id === insightId);
+    if (!insight) {
+      return false;
+    }
+    insight.dismissed = true;
+    if (!this.data.dismissedIds.includes(insightId)) {
+      this.data.dismissedIds.push(insightId);
+      if (this.data.dismissedIds.length > 500) {
+        this.data.dismissedIds = this.data.dismissedIds.slice(-500);
+      }
+    }
+    this.dirty = true;
+    await this.save();
+    return true;
+  }
+  /**
+   * Remove an insight entirely
+   */
+  async removeInsight(insightId) {
+    await this.load();
+    const index = this.data.insights.findIndex((i) => i.id === insightId);
+    if (index === -1) {
+      return false;
+    }
+    this.data.insights.splice(index, 1);
+    this.dirty = true;
+    await this.save();
+    return true;
+  }
+  /**
+   * Clear all cooldowns
+   */
+  async clearCooldowns() {
+    await this.load();
+    this.data.cooldowns = {};
+    this.dirty = true;
+    await this.save();
+  }
+  /**
+   * Get insight by ID
+   */
+  getInsight(insightId) {
+    return this.data.insights.find((i) => i.id === insightId);
+  }
+  /**
+   * Update an existing insight
+   */
+  async updateInsight(insightId, updates) {
+    await this.load();
+    const insight = this.data.insights.find((i) => i.id === insightId);
+    if (!insight) {
+      return false;
+    }
+    Object.assign(insight, updates);
+    this.dirty = true;
+    await this.save();
+    return true;
+  }
+  /**
+   * Get insights by category
+   */
+  getInsightsByCategory(category) {
+    return this.data.insights.filter((i) => i.category === category && !i.dismissed);
+  }
+  /**
+   * Get insights by type
+   */
+  getInsightsByType(type) {
+    return this.data.insights.filter((i) => i.type === type && !i.dismissed);
+  }
+  /**
+   * Get insights from the last N hours
+   */
+  getRecentInsights(hours = 24) {
+    const cutoff = Date.now() - hours * 60 * 60 * 1e3;
+    return this.data.insights.filter((i) => i.timestamp >= cutoff);
+  }
+  /**
+   * Get statistics about insights
+   */
+  getStats() {
+    const stats = {
+      total: this.data.insights.length,
+      active: 0,
+      dismissed: 0,
+      byCategory: {},
+      byType: {}
+    };
+    for (const insight of this.data.insights) {
+      if (insight.dismissed) {
+        stats.dismissed++;
+      } else {
+        stats.active++;
+      }
+      stats.byCategory[insight.category] = (stats.byCategory[insight.category] || 0) + 1;
+      stats.byType[insight.type] = (stats.byType[insight.type] || 0) + 1;
+    }
+    return stats;
+  }
+  /**
+   * Prune old insights (older than N days)
+   */
+  async pruneOldInsights(daysToKeep = 30) {
+    await this.load();
+    const cutoff = Date.now() - daysToKeep * 24 * 60 * 60 * 1e3;
+    const originalCount = this.data.insights.length;
+    this.data.insights = this.data.insights.filter((i) => i.timestamp >= cutoff);
+    const pruned = originalCount - this.data.insights.length;
+    if (pruned > 0) {
+      this.dirty = true;
+      await this.save();
+    }
+    return pruned;
+  }
+  /**
+   * Check if the store has been loaded
+   */
+  isLoaded() {
+    return this.loaded;
+  }
+  /**
+   * Force reload from disk
+   */
+  async reload() {
+    this.loaded = false;
+    this.dirty = false;
+    return this.load();
+  }
+};
+var insightStores = /* @__PURE__ */ new Map();
+function getInsightStore(projectPath) {
+  let store = insightStores.get(projectPath);
+  if (!store) {
+    store = new InsightStore(projectPath);
+    insightStores.set(projectPath, store);
+  }
+  return store;
+}
+
+// src/guardian/goal-manager.ts
+import { basename } from "path";
+var DEFAULT_CONFIG = {
+  minConfidence: 0.6,
+  maxActiveGoals: 3,
+  goalDurationDays: 14,
+  reductionTargetPercent: 50
+};
+var GoalManager = class {
+  projectPath;
+  config;
+  guardianState;
+  insightStore;
+  constructor(projectPath, config = {}) {
+    this.projectPath = projectPath;
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.guardianState = getGuardianState(projectPath);
+    this.insightStore = getInsightStore(projectPath);
+  }
+  /**
+   * Analyze incident patterns from memory
+   */
+  async analyzeIncidentPatterns() {
+    const patterns = [];
+    try {
+      const stats = await getMemoryStats(this.projectPath);
+      const recentIssues = await searchIssues("", {
+        workDir: this.projectPath,
+        limit: 500,
+        includeResolved: true
+      });
+      if (recentIssues.length < 5) {
+        return patterns;
+      }
+      const fileIssueCount = /* @__PURE__ */ new Map();
+      for (const { issue } of recentIssues) {
+        const file = issue.file;
+        fileIssueCount.set(file, (fileIssueCount.get(file) || 0) + 1);
+      }
+      const sortedFiles = [...fileIssueCount.entries()].sort((a, b) => b[1] - a[1]);
+      const dirIssueCount = /* @__PURE__ */ new Map();
+      for (const [file, count] of sortedFiles) {
+        const parts = file.split("/");
+        if (parts.length > 1) {
+          const dir = parts.slice(0, -1).join("/");
+          dirIssueCount.set(dir, (dirIssueCount.get(dir) || 0) + count);
+        }
+      }
+      const sortedDirs = [...dirIssueCount.entries()].sort((a, b) => b[1] - a[1]);
+      if (sortedDirs.length > 0) {
+        const [topDir, topDirCount] = sortedDirs[0];
+        const totalIssues = recentIssues.length;
+        const percentage = topDirCount / totalIssues * 100;
+        if (percentage >= 30) {
+          patterns.push({
+            type: "file-cluster",
+            description: `${basename(topDir)}/ has ${percentage.toFixed(0)}% of issues`,
+            metric: `${topDir}_issues`,
+            currentValue: topDirCount,
+            suggestedTarget: Math.floor(topDirCount * (1 - this.config.reductionTargetPercent / 100)),
+            confidence: Math.min(0.9, percentage / 100 + 0.3),
+            evidence: [
+              `${topDirCount} issues in ${topDir}/`,
+              `${percentage.toFixed(0)}% of total issues`,
+              `Top files: ${sortedFiles.filter(([f]) => f.startsWith(topDir)).slice(0, 3).map(([f]) => basename(f)).join(", ")}`
+            ],
+            category: "quality"
+          });
+        }
+      }
+      const criticalCount = recentIssues.filter((r) => r.issue.severity === "critical").length;
+      const seriousCount = recentIssues.filter((r) => r.issue.severity === "serious").length;
+      if (criticalCount >= 3) {
+        patterns.push({
+          type: "severity-trend",
+          description: `${criticalCount} critical issues need attention`,
+          metric: "critical_issues",
+          currentValue: criticalCount,
+          suggestedTarget: 0,
+          confidence: Math.min(0.95, 0.5 + criticalCount * 0.1),
+          evidence: [
+            `${criticalCount} critical severity issues`,
+            `${seriousCount} serious severity issues`,
+            "Critical issues should be zero for production safety"
+          ],
+          category: "security"
+        });
+      }
+      const agentIssueCount = /* @__PURE__ */ new Map();
+      for (const { issue } of recentIssues) {
+        agentIssueCount.set(issue.agent, (agentIssueCount.get(issue.agent) || 0) + 1);
+      }
+      const sortedAgents = [...agentIssueCount.entries()].sort((a, b) => b[1] - a[1]);
+      if (sortedAgents.length > 0) {
+        const [topAgent, topAgentCount] = sortedAgents[0];
+        const percentage = topAgentCount / recentIssues.length * 100;
+        if (percentage >= 40 && topAgentCount >= 5) {
+          const category = this.agentToCategory(topAgent);
+          patterns.push({
+            type: "agent-concentration",
+            description: `${topAgent} skill finds ${percentage.toFixed(0)}% of issues`,
+            metric: `${topAgent}_issues`,
+            currentValue: topAgentCount,
+            suggestedTarget: Math.floor(topAgentCount * 0.5),
+            confidence: Math.min(0.85, percentage / 100 + 0.2),
+            evidence: [
+              `${topAgentCount} issues from ${topAgent}`,
+              `${percentage.toFixed(0)}% of all issues`,
+              `Suggests focused improvement in ${category} area`
+            ],
+            category
+          });
+        }
+      }
+      if (stats.improvementTrend === "improving") {
+        patterns.push({
+          type: "time-pattern",
+          description: "Quality is improving - maintain the streak",
+          metric: "clean_scans",
+          currentValue: 0,
+          suggestedTarget: 5,
+          confidence: 0.7,
+          evidence: [
+            "Historical trend shows improvement",
+            "Momentum is positive",
+            "Streak goal can maintain motivation"
+          ],
+          category: "quality"
+        });
+      }
+    } catch (error) {
+      console.error("Failed to analyze incident patterns:", error);
+    }
+    return patterns;
+  }
+  /**
+   * Convert agent name to category
+   */
+  agentToCategory(agent) {
+    const categoryMap = {
+      "security": "security",
+      "privacy": "security",
+      "soc2": "security",
+      "performance": "performance",
+      "accessibility": "quality",
+      "test": "coverage",
+      "typecheck": "quality",
+      "bug-finding": "quality"
+    };
+    return categoryMap[agent] || "general";
+  }
+  /**
+   * Generate goal opportunities from patterns
+   */
+  async generateGoalOpportunities() {
+    const patterns = await this.analyzeIncidentPatterns();
+    const opportunities = [];
+    const validPatterns = patterns.filter((p) => p.confidence >= this.config.minConfidence);
+    await this.guardianState.load();
+    const activeGoals = this.guardianState.getActiveGoals();
+    const slotsAvailable = this.config.maxActiveGoals - activeGoals.length;
+    if (slotsAvailable <= 0) {
+      return opportunities;
+    }
+    for (const pattern of validPatterns.slice(0, slotsAvailable)) {
+      const goalType = pattern.type === "time-pattern" ? "streak" : "reduction";
+      const deadline = /* @__PURE__ */ new Date();
+      deadline.setDate(deadline.getDate() + this.config.goalDurationDays);
+      opportunities.push({
+        pattern,
+        goal: {
+          description: this.generateGoalDescription(pattern),
+          type: goalType,
+          metric: pattern.metric,
+          target: pattern.suggestedTarget,
+          currentValue: pattern.currentValue,
+          startValue: pattern.currentValue,
+          status: "active",
+          autoGenerated: true,
+          confidence: pattern.confidence,
+          deadline: deadline.toISOString(),
+          category: pattern.category,
+          evidence: pattern.evidence
+        },
+        reasoning: this.generateGoalReasoning(pattern)
+      });
+    }
+    return opportunities;
+  }
+  /**
+   * Generate a human-readable goal description
+   */
+  generateGoalDescription(pattern) {
+    switch (pattern.type) {
+      case "file-cluster":
+        return `Reduce issues in ${pattern.description.split(" ")[0]} by ${this.config.reductionTargetPercent}%`;
+      case "severity-trend":
+        return "Eliminate all critical issues";
+      case "agent-concentration":
+        return `Reduce ${pattern.description.split(" ")[0]} issues by 50%`;
+      case "time-pattern":
+        return "Achieve 5 consecutive clean scans";
+      default:
+        return pattern.description;
+    }
+  }
+  /**
+   * Generate reasoning for why this goal was suggested
+   */
+  generateGoalReasoning(pattern) {
+    const evidence = pattern.evidence.join(". ");
+    return `Based on analysis: ${evidence}. Confidence: ${(pattern.confidence * 100).toFixed(0)}%`;
+  }
+  /**
+   * Auto-generate goals and create them (with auto-generated status)
+   * 
+   * Returns goals that need user acceptance.
+   */
+  async autoGenerateGoals() {
+    const opportunities = await this.generateGoalOpportunities();
+    const createdGoals = [];
+    for (const opportunity of opportunities) {
+      const goal = {
+        id: `goal-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        ...opportunity.goal,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await this.guardianState.addGoal(goal);
+      createdGoals.push(goal);
+      if (this.insightStore.canCreateInsight("goal-suggestion")) {
+        const insight = {
+          id: `insight-goal-${goal.id}`,
+          type: "suggestion",
+          message: `\u{1F3AF} New goal suggested: ${goal.description}`,
+          context: opportunity.reasoning,
+          suggestedAction: "Review and accept/reject this goal",
+          relatedIssues: [],
+          priority: 6,
+          timestamp: Date.now(),
+          dismissed: false,
+          category: "progress",
+          details: {
+            examples: opportunity.pattern.evidence
+          }
+        };
+        await this.insightStore.addInsight(insight);
+        await this.insightStore.markInsightCreated("goal-suggestion");
+      }
+    }
+    return createdGoals;
+  }
+  /**
+   * Update goal progress based on current state
+   */
+  async updateGoalProgress() {
+    await this.guardianState.load();
+    const activeGoals = this.guardianState.getActiveGoals();
+    for (const goal of activeGoals) {
+      const currentValue = await this.measureGoalMetric(goal);
+      await this.guardianState.updateGoal(goal.id, { currentValue });
+      if (this.isGoalAchieved(goal, currentValue)) {
+        await this.guardianState.updateGoal(goal.id, {
+          status: "achieved",
+          achievedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          currentValue
+        });
+        await this.celebrateGoalAchievement(goal);
+      }
+      if (goal.deadline) {
+        const deadline = new Date(goal.deadline);
+        if (Date.now() > deadline.getTime() && !this.isGoalAchieved(goal, currentValue)) {
+          await this.guardianState.updateGoal(goal.id, {
+            status: "failed",
+            currentValue
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Measure the current value of a goal's metric
+   * 
+   * Supports both structured metrics and semantic/natural language goals
+   */
+  async measureGoalMetric(goal) {
+    try {
+      const issues = await searchIssues("", {
+        workDir: this.projectPath,
+        limit: 1e3,
+        includeResolved: false
+      });
+      if (goal.metric.endsWith("_issues")) {
+        const prefix = goal.metric.replace("_issues", "");
+        if (prefix.includes("/")) {
+          return issues.filter((r) => r.issue.file.startsWith(prefix)).length;
+        }
+        return issues.filter((r) => r.issue.agent === prefix).length;
+      }
+      if (goal.metric === "critical_issues") {
+        return issues.filter((r) => r.issue.severity === "critical").length;
+      }
+      const desc = goal.description.toLowerCase();
+      if (desc.includes("dead code") || desc.includes("unused") || desc.includes("remove unused")) {
+        const deadCodeIssues = issues.filter((r) => {
+          const msg = r.issue.issue.toLowerCase();
+          return msg.includes("unused") || msg.includes("dead code") || msg.includes("never used") || msg.includes("unreachable") || msg.includes("no-unused") || msg.includes("defined but never");
+        });
+        return deadCodeIssues.length;
+      }
+      if (desc.includes("security") || desc.includes("vulnerab") || desc.includes("fix security")) {
+        const securityIssues = issues.filter(
+          (r) => r.issue.agent === "security" || r.issue.agent === "privacy" || r.issue.severity === "critical"
+        );
+        return securityIssues.length;
+      }
+      if (desc.includes("type") || desc.includes("typescript") || desc.includes("any type")) {
+        const typeIssues = issues.filter(
+          (r) => r.issue.agent === "typecheck" || r.issue.issue.toLowerCase().includes("type") || r.issue.issue.toLowerCase().includes("any")
+        );
+        return typeIssues.length;
+      }
+      if (desc.includes("test") || desc.includes("coverage")) {
+        const testIssues = issues.filter(
+          (r) => r.issue.agent === "test" || r.issue.issue.toLowerCase().includes("test") || r.issue.issue.toLowerCase().includes("coverage")
+        );
+        return testIssues.length;
+      }
+      if (desc.includes("performance") || desc.includes("slow") || desc.includes("optimize")) {
+        const perfIssues = issues.filter(
+          (r) => r.issue.agent === "performance" || r.issue.issue.toLowerCase().includes("performance") || r.issue.issue.toLowerCase().includes("slow")
+        );
+        return perfIssues.length;
+      }
+      if (desc.includes("accessibility") || desc.includes("a11y") || desc.includes("accessible")) {
+        const a11yIssues = issues.filter(
+          (r) => r.issue.agent === "accessibility" || r.issue.issue.toLowerCase().includes("accessibility")
+        );
+        return a11yIssues.length;
+      }
+      if (desc.includes("bug") || desc.includes("fix") || desc.includes("error")) {
+        const bugIssues = issues.filter(
+          (r) => r.issue.agent === "bug-finding" || r.issue.severity === "critical" || r.issue.severity === "serious"
+        );
+        return bugIssues.length;
+      }
+      if (desc.includes("quality") || desc.includes("clean") || desc.includes("improve")) {
+        return issues.length;
+      }
+      return issues.length;
+    } catch {
+      return goal.currentValue;
+    }
+  }
+  /**
+   * Check if a goal has been achieved
+   */
+  isGoalAchieved(goal, currentValue) {
+    switch (goal.type) {
+      case "reduction":
+        return currentValue <= goal.target;
+      case "score":
+        return currentValue >= goal.target;
+      case "streak":
+        return currentValue >= goal.target;
+      default:
+        return currentValue <= goal.target;
+    }
+  }
+  /**
+   * Create a celebration insight for goal achievement
+   */
+  async celebrateGoalAchievement(goal) {
+    const insight = {
+      id: `insight-achieved-${goal.id}`,
+      type: "celebration",
+      message: `\u{1F389} Goal achieved: ${goal.description}!`,
+      context: `Started at ${goal.startValue}, now at ${goal.currentValue}. Target was ${goal.target}.`,
+      relatedIssues: [],
+      priority: 8,
+      timestamp: Date.now(),
+      dismissed: false,
+      category: "progress"
+    };
+    await this.insightStore.addInsight(insight);
+  }
+  /**
+   * Accept an auto-generated goal
+   */
+  async acceptGoal(goalId) {
+    return this.guardianState.respondToGoal(goalId, true);
+  }
+  /**
+   * Reject an auto-generated goal
+   */
+  async rejectGoal(goalId) {
+    return this.guardianState.respondToGoal(goalId, false);
+  }
+  /**
+   * Get pending auto-generated goals (awaiting acceptance)
+   */
+  getPendingGoals() {
+    return this.guardianState.getAutoGeneratedGoals().filter((g) => g.status === "active");
+  }
+  /**
+   * Get goal progress summary
+   */
+  getGoalProgressSummary() {
+    const goals = this.guardianState.getAllGoals();
+    return {
+      active: goals.filter((g) => g.status === "active").length,
+      achieved: goals.filter((g) => g.status === "achieved").length,
+      failed: goals.filter((g) => g.status === "failed").length,
+      pending: goals.filter((g) => g.autoGenerated && g.status === "active").length
+    };
+  }
+};
+async function calculateAdaptiveScanFrequency(projectPath) {
+  const guardianState = getGuardianState(projectPath);
+  await guardianState.load();
+  try {
+    const stats = await getMemoryStats(projectPath);
+    const issues = await searchIssues("", {
+      workDir: projectPath,
+      limit: 100,
+      includeResolved: false
+    });
+    const criticalCount = issues.filter((r) => r.issue.severity === "critical").length;
+    const seriousCount = issues.filter((r) => r.issue.severity === "serious").length;
+    if (criticalCount >= 3) {
+      return {
+        frequencyMs: 6e4,
+        reason: `${criticalCount} critical issues detected - scanning frequently`
+      };
+    }
+    if (criticalCount > 0 || seriousCount >= 5) {
+      return {
+        frequencyMs: 12e4,
+        reason: `Critical or many serious issues - elevated scan frequency`
+      };
+    }
+    if (seriousCount > 0) {
+      return {
+        frequencyMs: 18e4,
+        reason: `${seriousCount} serious issues - moderate scan frequency`
+      };
+    }
+    if (stats.totalIssues > 10) {
+      return {
+        frequencyMs: 3e5,
+        reason: "Some issues present - standard scan frequency"
+      };
+    }
+    return {
+      frequencyMs: 6e5,
+      reason: "Code looks good - relaxed scan frequency"
+    };
+  } catch {
+    return {
+      frequencyMs: 3e5,
+      reason: "Default scan frequency (5 min)"
+    };
+  }
+}
+async function adaptScanFrequency(projectPath) {
+  const guardianState = getGuardianState(projectPath);
+  const { frequencyMs } = await calculateAdaptiveScanFrequency(projectPath);
+  await guardianState.setScanFrequency(frequencyMs);
+  return frequencyMs;
+}
+var goalManagers = /* @__PURE__ */ new Map();
+function getGoalManager(projectPath) {
+  let manager = goalManagers.get(projectPath);
+  if (!manager) {
+    manager = new GoalManager(projectPath);
+    goalManagers.set(projectPath, manager);
+  }
+  return manager;
+}
+function clearGoalManagers() {
+  goalManagers.clear();
+}
+
+export {
+  getInsightStore,
+  GoalManager,
+  calculateAdaptiveScanFrequency,
+  adaptScanFrequency,
+  getGoalManager,
+  clearGoalManagers
+};
+//# sourceMappingURL=chunk-D3DMONAJ.js.map