@triedotdev/mcp 1.0.168 → 1.0.170

package/dist/chunk-MRHKX5M5.js

@@ -1,662 +0,0 @@
-import {
-  getInsightStore
-} from "./chunk-T63OHG4Q.js";
-import {
-  getMemoryStats,
-  searchIssues
-} from "./chunk-XE6KQRKZ.js";
-import {
-  getProjectState
-} from "./chunk-GTKYBOXL.js";
-
-// src/agent/goal-manager.ts
-import { basename } from "path";
-var DEFAULT_CONFIG = {
-  minConfidence: 0.6,
-  maxActiveGoals: 3,
-  goalDurationDays: 14,
-  reductionTargetPercent: 50
-};
-var GoalManager = class {
-  projectPath;
-  config;
-  projectState;
-  insightStore;
-  constructor(projectPath, config = {}) {
-    this.projectPath = projectPath;
-    this.config = { ...DEFAULT_CONFIG, ...config };
-    this.projectState = getProjectState(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 topDirEntry = sortedDirs[0];
-        if (!topDirEntry) return patterns;
-        const [topDir, topDirCount] = topDirEntry;
-        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 topAgentEntry = sortedAgents[0];
-        if (!topAgentEntry) return patterns;
-        const [topAgent, topAgentCount] = topAgentEntry;
-        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",
-      "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.projectState.load();
-    const activeGoals = this.projectState.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.projectState.addGoal(goal);
-      createdGoals.push(goal);
-      if (this.insightStore.canCreateInsight("goal-suggestion")) {
-        const insight = {
-          id: `insight-goal-${goal.id}`,
-          type: "suggestion",
-          message: `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.projectState.load();
-    const activeGoals = this.projectState.getActiveGoals();
-    for (const goal of activeGoals) {
-      const currentValue = await this.measureGoalMetric(goal);
-      await this.projectState.updateGoal(goal.id, { currentValue });
-      if (!goal.autoGenerated) {
-        console.debug(`[GoalManager] Skipping auto-achieve for user goal: "${goal.description.substring(0, 50)}..." (autoGenerated=${goal.autoGenerated})`);
-        continue;
-      }
-      if (goal.autoGenerated !== true) {
-        console.warn(`[GoalManager] SAFETY: Blocking auto-achieve for ambiguous goal: "${goal.description.substring(0, 50)}..." (autoGenerated=${goal.autoGenerated})`);
-        continue;
-      }
-      if (this.isGoalAchieved(goal, currentValue)) {
-        console.debug(`[GoalManager] Auto-achieving AI goal: "${goal.description.substring(0, 50)}..."`);
-        await this.projectState.updateGoal(goal.id, {
-          status: "achieved",
-          achievedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          achievedBy: "agent",
-          currentValue
-        });
-        try {
-          const { getStorage } = await import("./tiered-storage-Z3YCR465.js");
-          const storage = getStorage(this.projectPath);
-          await storage.initialize();
-          const resolved = await storage.resolveNudgesForGoal(goal.description);
-          if (resolved > 0) {
-            console.debug(`[GoalManager] Auto-resolved ${resolved} nudge(s) for achieved goal`);
-          }
-        } catch (e) {
-          console.debug("[GoalManager] Failed to resolve nudges for achieved goal:", e);
-        }
-        await this.celebrateGoalAchievement(goal);
-      }
-      if (goal.deadline) {
-        const deadline = new Date(goal.deadline);
-        if (Date.now() > deadline.getTime() && !this.isGoalAchieved(goal, currentValue)) {
-          await this.projectState.updateGoal(goal.id, {
-            status: "failed",
-            currentValue
-          });
-        }
-      }
-    }
-  }
-  /**
-   * Measure the current value of a goal's metric
-   * 
-   * Supports both structured metrics and semantic/natural language goals.
-   * For custom goals, counts goal-violation issues that match this goal's description.
-   */
-  async measureGoalMetric(goal) {
-    try {
-      const issues = await searchIssues("", {
-        workDir: this.projectPath,
-        limit: 1e3,
-        includeResolved: false
-      });
-      const goalViolations = issues.filter(
-        (r) => r.issue.agent === "goal-violation" && r.issue.issue.includes(`Goal "${goal.description}"`)
-      );
-      if (goalViolations.length > 0) {
-        return goalViolations.length;
-      }
-      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();
-      const dirMatch = goal.description.match(/in\s+(?:the\s+)?(\S+?)(?:\s+(?:module|folder|directory|dir))?(?:\s|$)/i);
-      if (dirMatch && dirMatch[1]) {
-        const dirName = dirMatch[1].toLowerCase().replace(/[/\\]$/, "");
-        const matchingIssues = issues.filter((r) => {
-          const filePath = r.issue.file.toLowerCase();
-          return filePath.includes(`/${dirName}/`) || filePath.includes(`\\${dirName}\\`) || filePath.startsWith(`${dirName}/`) || filePath.startsWith(`${dirName}\\`);
-        });
-        if (matchingIssues.length > 0 || desc.includes(dirName)) {
-          return matchingIssues.length;
-        }
-      }
-      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.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 resolvedDetails = await this.getResolvedIssuesForGoal(goal);
-    if (goal.startValue === void 0 || goal.startValue === null) {
-      throw new Error(`Goal ${goal.id} missing startValue`);
-    }
-    if (goal.currentValue === void 0 || goal.currentValue === null) {
-      throw new Error(`Goal ${goal.id} missing currentValue`);
-    }
-    if (goal.target === void 0 || goal.target === null) {
-      throw new Error(`Goal ${goal.id} missing target`);
-    }
-    for (let i = 0; i < resolvedDetails.length; i++) {
-      const issue = resolvedDetails[i];
-      if (!issue) {
-        throw new Error(`Resolved issue at index ${i} is null/undefined`);
-      }
-      if (!issue.file) {
-        throw new Error(`Resolved issue at index ${i} missing file field`);
-      }
-      if (!issue.issue) {
-        throw new Error(`Resolved issue at index ${i} missing issue description`);
-      }
-      if (!issue.agent) {
-        throw new Error(`Resolved issue at index ${i} missing agent field`);
-      }
-    }
-    const insight = {
-      id: `insight-achieved-${goal.id}`,
-      type: "celebration",
-      message: `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",
-      details: {
-        resolvedCount: resolvedDetails.length,
-        resolvedIssues: resolvedDetails.slice(0, 20).map((issue) => ({
-          file: issue.file,
-          line: issue.line,
-          issue: issue.issue,
-          agent: issue.agent,
-          resolvedAt: issue.resolvedAt
-        })),
-        summary: resolvedDetails.length > 0 ? `Resolved ${resolvedDetails.length} issue${resolvedDetails.length > 1 ? "s" : ""} matching this goal` : "Progress tracked via metric reduction"
-      }
-    };
-    if (!insight.details) {
-      throw new Error("Failed to create details object for goal achievement insight");
-    }
-    if (insight.details.resolvedCount === void 0) {
-      throw new Error("resolvedCount is undefined in goal achievement insight");
-    }
-    if (insight.details.resolvedCount > 0 && (!insight.details.resolvedIssues || insight.details.resolvedIssues.length === 0)) {
-      throw new Error(`resolvedCount is ${insight.details.resolvedCount} but resolvedIssues array is empty`);
-    }
-    if (insight.details.resolvedCount !== insight.details.resolvedIssues?.length) {
-      throw new Error(`resolvedCount (${insight.details.resolvedCount}) doesn't match resolvedIssues length (${insight.details.resolvedIssues?.length})`);
-    }
-    await this.insightStore.addInsight(insight);
-  }
-  /**
-   * Get resolved issues that match a goal's metric pattern
-   */
-  async getResolvedIssuesForGoal(goal) {
-    try {
-      const allResolved = await searchIssues("", {
-        workDir: this.projectPath,
-        limit: 1e3,
-        includeResolved: true
-      });
-      const resolved = allResolved.map((r) => r.issue).filter((issue) => issue.resolved === true);
-      const desc = goal.description.toLowerCase();
-      const metric = goal.metric.toLowerCase();
-      let matchingResolved = resolved;
-      if (metric.endsWith("_issues")) {
-        const prefix = metric.replace("_issues", "");
-        if (prefix.includes("/")) {
-          matchingResolved = resolved.filter((i) => i.file.startsWith(prefix));
-        } else {
-          matchingResolved = resolved.filter((i) => i.agent === prefix);
-        }
-      } else if (metric === "critical_issues") {
-        matchingResolved = resolved.filter((i) => i.severity === "critical");
-      } else {
-        if (desc.includes("dead code") || desc.includes("unused") || desc.includes("remove unused")) {
-          matchingResolved = resolved.filter((i) => {
-            const msg = i.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");
-          });
-        } else if (desc.includes("security") || desc.includes("vulnerab") || desc.includes("fix security")) {
-          matchingResolved = resolved.filter(
-            (i) => i.agent === "security" || i.severity === "critical"
-          );
-        } else if (desc.includes("type") || desc.includes("typescript") || desc.includes("any type")) {
-          matchingResolved = resolved.filter(
-            (i) => i.agent === "typecheck" || i.issue.toLowerCase().includes("type") || i.issue.toLowerCase().includes("any")
-          );
-        } else if (desc.includes("test") || desc.includes("coverage")) {
-          matchingResolved = resolved.filter(
-            (i) => i.agent === "test" || i.issue.toLowerCase().includes("test") || i.issue.toLowerCase().includes("coverage")
-          );
-        } else if (desc.includes("performance") || desc.includes("slow") || desc.includes("optimize")) {
-          matchingResolved = resolved.filter(
-            (i) => i.agent === "performance" || i.issue.toLowerCase().includes("performance") || i.issue.toLowerCase().includes("slow")
-          );
-        } else if (desc.includes("accessibility") || desc.includes("a11y") || desc.includes("accessible")) {
-          matchingResolved = resolved.filter(
-            (i) => i.agent === "accessibility" || i.issue.toLowerCase().includes("accessibility")
-          );
-        } else if (desc.includes("bug") || desc.includes("fix") || desc.includes("error")) {
-          matchingResolved = resolved.filter(
-            (i) => i.agent === "bug-finding" || i.severity === "critical" || i.severity === "serious"
-          );
-        }
-      }
-      const goalCreatedAt = new Date(goal.createdAt).getTime();
-      const goalAchievedAt = goal.achievedAt ? new Date(goal.achievedAt).getTime() : Date.now();
-      return matchingResolved.filter((issue) => {
-        if (!issue.resolvedAt) return false;
-        const resolvedAt = new Date(issue.resolvedAt).getTime();
-        return resolvedAt >= goalCreatedAt && resolvedAt <= goalAchievedAt;
-      }).sort((a, b) => {
-        const aTime = a.resolvedAt ? new Date(a.resolvedAt).getTime() : 0;
-        const bTime = b.resolvedAt ? new Date(b.resolvedAt).getTime() : 0;
-        return bTime - aTime;
-      });
-    } catch {
-      return [];
-    }
-  }
-  /**
-   * Accept an auto-generated goal
-   */
-  async acceptGoal(goalId) {
-    return this.projectState.respondToGoal(goalId, true);
-  }
-  /**
-   * Reject an auto-generated goal
-   */
-  async rejectGoal(goalId) {
-    return this.projectState.respondToGoal(goalId, false);
-  }
-  /**
-   * Get pending auto-generated goals (awaiting acceptance)
-   */
-  getPendingGoals() {
-    return this.projectState.getAutoGeneratedGoals().filter((g) => g.status === "active");
-  }
-  /**
-   * Get goal progress summary
-   */
-  getGoalProgressSummary() {
-    const goals = this.projectState.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 projectState = getProjectState(projectPath);
-  await projectState.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 projectState = getProjectState(projectPath);
-  const { frequencyMs } = await calculateAdaptiveScanFrequency(projectPath);
-  await projectState.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 {
-  GoalManager,
-  calculateAdaptiveScanFrequency,
-  adaptScanFrequency,
-  getGoalManager,
-  clearGoalManagers
-};
-//# sourceMappingURL=chunk-MRHKX5M5.js.map