@triedotdev/mcp 1.0.113 → 1.0.114

package/dist/chunk-55DOQNHJ.js

@@ -0,0 +1,772 @@
+import {
+  BackupManager,
+  CompactedSummariesIndexSchema,
+  IssueIndexSchema,
+  safeParseAndValidate
+} from "./chunk-KRH642MT.js";
+import {
+  appendIssuesToLedger
+} from "./chunk-YR4BMGYO.js";
+import {
+  atomicWriteJSON
+} from "./chunk-43X6JBEM.js";
+import {
+  getTrieDirectory,
+  getWorkingDirectory
+} from "./chunk-R4AAPFXC.js";
+
+// src/memory/compactor.ts
+import { mkdir, readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+async function compactOldIssues(issues, options = {}) {
+  const keepDays = options.keepDays ?? 30;
+  const minIssues = options.minIssuesToCompact ?? 100;
+  const cutoffDate = /* @__PURE__ */ new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - keepDays);
+  const oldIssues = issues.filter((i) => new Date(i.timestamp) < cutoffDate);
+  const recentIssues = issues.filter((i) => new Date(i.timestamp) >= cutoffDate);
+  if (oldIssues.length < minIssues) {
+    return { summary: null, remaining: issues };
+  }
+  const summary = buildSummary(oldIssues);
+  return { summary, remaining: recentIssues };
+}
+function buildSummary(issues) {
+  const sorted = issues.sort(
+    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
+  const bySeverity = {};
+  const byAgent = {};
+  const patternMap = /* @__PURE__ */ new Map();
+  const fileCount = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    bySeverity[issue.severity] = (bySeverity[issue.severity] || 0) + 1;
+    byAgent[issue.agent] = (byAgent[issue.agent] || 0) + 1;
+    const patternKey = normalizePattern(issue.issue);
+    const existing = patternMap.get(patternKey);
+    if (existing) {
+      existing.count++;
+    } else {
+      patternMap.set(patternKey, { count: 1, issue });
+    }
+    const fileName = issue.file.split("/").pop() || issue.file;
+    fileCount.set(fileName, (fileCount.get(fileName) || 0) + 1);
+  }
+  const topPatterns = Array.from(patternMap.entries()).sort((a, b) => b[1].count - a[1].count).slice(0, 10).map(([pattern, data]) => ({
+    pattern: pattern.slice(0, 100),
+    count: data.count,
+    severity: data.issue.severity,
+    agent: data.issue.agent,
+    exampleFix: data.issue.fix.slice(0, 200)
+  }));
+  const hotFiles = Array.from(fileCount.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([file, count]) => ({ file, count }));
+  return {
+    period: `${sorted[0]?.timestamp.split("T")[0]} to ${sorted[sorted.length - 1]?.timestamp.split("T")[0]}`,
+    startDate: sorted[0]?.timestamp || "",
+    endDate: sorted[sorted.length - 1]?.timestamp || "",
+    totalIssues: issues.length,
+    resolvedCount: issues.filter((i) => i.resolved).length,
+    bySeverity,
+    byAgent,
+    topPatterns,
+    hotFiles,
+    compactedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function normalizePattern(text) {
+  return text.toLowerCase().replace(/`[^`]+`/g, "CODE").replace(/\b\d+\b/g, "N").replace(/["']/g, "").replace(/\s+/g, " ").trim().slice(0, 150);
+}
+async function saveCompactedSummary(summary, projectDir) {
+  const memoryDir = join(getTrieDirectory(projectDir), "memory");
+  await mkdir(memoryDir, { recursive: true });
+  const summaryPath = join(memoryDir, "compacted-summaries.json");
+  let summaries = [];
+  try {
+    if (existsSync(summaryPath)) {
+      const content = await readFile(summaryPath, "utf-8");
+      const result = safeParseAndValidate(content, CompactedSummariesIndexSchema);
+      if (result.success) {
+        summaries = result.data;
+      }
+    }
+  } catch {
+    summaries = [];
+  }
+  summaries.push(summary);
+  if (summaries.length > 12) {
+    summaries = summaries.slice(-12);
+  }
+  const backupManager = new BackupManager(summaryPath);
+  await backupManager.createBackup();
+  await atomicWriteJSON(summaryPath, summaries);
+}
+async function loadCompactedSummaries(projectDir) {
+  const summaryPath = join(getTrieDirectory(projectDir), "memory", "compacted-summaries.json");
+  try {
+    if (existsSync(summaryPath)) {
+      const content = await readFile(summaryPath, "utf-8");
+      const result = safeParseAndValidate(content, CompactedSummariesIndexSchema);
+      if (result.success) {
+        return result.data;
+      }
+      const backupManager = new BackupManager(summaryPath);
+      if (await backupManager.recoverFromBackup()) {
+        const recovered = await readFile(summaryPath, "utf-8");
+        const recoveredResult = safeParseAndValidate(recovered, CompactedSummariesIndexSchema);
+        if (recoveredResult.success) {
+          return recoveredResult.data;
+        }
+      }
+    }
+  } catch {
+  }
+  return [];
+}
+async function getHistoricalInsights(projectDir) {
+  const summaries = await loadCompactedSummaries(projectDir);
+  if (summaries.length === 0) {
+    return {
+      totalHistoricalIssues: 0,
+      recurringPatterns: [],
+      improvementTrend: "unknown"
+    };
+  }
+  const totalHistoricalIssues = summaries.reduce((sum, s) => sum + s.totalIssues, 0);
+  const patternCounts = /* @__PURE__ */ new Map();
+  for (const summary of summaries) {
+    for (const pattern of summary.topPatterns) {
+      const key = pattern.pattern;
+      const existing = patternCounts.get(key);
+      if (existing) {
+        existing.count += pattern.count;
+        existing.appearances++;
+      } else {
+        patternCounts.set(key, { ...pattern, appearances: 1 });
+      }
+    }
+  }
+  const recurringPatterns = Array.from(patternCounts.values()).filter((p) => p.appearances >= 2).sort((a, b) => b.count - a.count).slice(0, 5);
+  let improvementTrend = "unknown";
+  if (summaries.length >= 2) {
+    const recent = summaries.slice(-2);
+    const olderCount = recent[0]?.totalIssues || 0;
+    const newerCount = recent[1]?.totalIssues || 0;
+    if (newerCount < olderCount * 0.8) {
+      improvementTrend = "improving";
+    } else if (newerCount > olderCount * 1.2) {
+      improvementTrend = "declining";
+    } else {
+      improvementTrend = "stable";
+    }
+  }
+  return {
+    totalHistoricalIssues,
+    recurringPatterns,
+    improvementTrend
+  };
+}
+
+// src/memory/issue-store.ts
+import { mkdir as mkdir2, writeFile, readFile as readFile2, readdir } from "fs/promises";
+import { createHash } from "crypto";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/memory/bm25.ts
+var BM25Index = class _BM25Index {
+  documents = /* @__PURE__ */ new Map();
+  termFrequencies = /* @__PURE__ */ new Map();
+  documentFrequencies = /* @__PURE__ */ new Map();
+  documentLengths = /* @__PURE__ */ new Map();
+  avgDocLength = 0;
+  k1 = 1.5;
+  b = 0.75;
+  /**
+   * Add a document to the index
+   */
+  addDocument(doc) {
+    const tokens = this.tokenize(doc.text);
+    this.documents.set(doc.id, doc);
+    this.documentLengths.set(doc.id, tokens.length);
+    const termFreq = /* @__PURE__ */ new Map();
+    const seenTerms = /* @__PURE__ */ new Set();
+    for (const token of tokens) {
+      termFreq.set(token, (termFreq.get(token) || 0) + 1);
+      if (!seenTerms.has(token)) {
+        seenTerms.add(token);
+        this.documentFrequencies.set(token, (this.documentFrequencies.get(token) || 0) + 1);
+      }
+    }
+    this.termFrequencies.set(doc.id, termFreq);
+    this.updateAvgDocLength();
+  }
+  /**
+   * Add multiple documents
+   */
+  addDocuments(docs) {
+    for (const doc of docs) {
+      this.addDocument(doc);
+    }
+  }
+  /**
+   * Search the index
+   */
+  search(query, limit = 10) {
+    const queryTokens = this.tokenize(query);
+    const scores = /* @__PURE__ */ new Map();
+    const N = this.documents.size;
+    for (const [docId] of this.documents) {
+      let score = 0;
+      const docLength = this.documentLengths.get(docId) || 0;
+      const termFreqs = this.termFrequencies.get(docId);
+      if (!termFreqs) continue;
+      for (const term of queryTokens) {
+        const tf = termFreqs.get(term) || 0;
+        if (tf === 0) continue;
+        const df = this.documentFrequencies.get(term) || 0;
+        const idf = Math.log((N - df + 0.5) / (df + 0.5) + 1);
+        const numerator = tf * (this.k1 + 1);
+        const denominator = tf + this.k1 * (1 - this.b + this.b * (docLength / this.avgDocLength));
+        score += idf * (numerator / denominator);
+      }
+      if (score > 0) {
+        scores.set(docId, score);
+      }
+    }
+    return Array.from(scores.entries()).sort((a, b) => b[1] - a[1]).slice(0, limit).map(([id, score]) => {
+      const metadata = this.documents.get(id)?.metadata;
+      const result = { id, score };
+      if (metadata !== void 0) {
+        result.metadata = metadata;
+      }
+      return result;
+    });
+  }
+  /**
+   * Get document count
+   */
+  get size() {
+    return this.documents.size;
+  }
+  /**
+   * Clear the index
+   */
+  clear() {
+    this.documents.clear();
+    this.termFrequencies.clear();
+    this.documentFrequencies.clear();
+    this.documentLengths.clear();
+    this.avgDocLength = 0;
+  }
+  /**
+   * Serialize the index to JSON
+   */
+  serialize() {
+    return JSON.stringify({
+      documents: Array.from(this.documents.entries()),
+      termFrequencies: Array.from(this.termFrequencies.entries()).map(([k, v]) => [k, Array.from(v.entries())]),
+      documentFrequencies: Array.from(this.documentFrequencies.entries()),
+      documentLengths: Array.from(this.documentLengths.entries()),
+      avgDocLength: this.avgDocLength
+    });
+  }
+  /**
+   * Load from serialized JSON
+   */
+  static deserialize(json) {
+    const data = JSON.parse(json);
+    const index = new _BM25Index();
+    index.documents = new Map(data.documents);
+    index.termFrequencies = new Map(data.termFrequencies.map(([k, v]) => [k, new Map(v)]));
+    index.documentFrequencies = new Map(data.documentFrequencies);
+    index.documentLengths = new Map(data.documentLengths);
+    index.avgDocLength = data.avgDocLength;
+    return index;
+  }
+  tokenize(text) {
+    return text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((token) => token.length > 2 && !this.isStopWord(token));
+  }
+  isStopWord(word) {
+    const stopWords = /* @__PURE__ */ new Set([
+      "the",
+      "be",
+      "to",
+      "of",
+      "and",
+      "a",
+      "in",
+      "that",
+      "have",
+      "i",
+      "it",
+      "for",
+      "not",
+      "on",
+      "with",
+      "he",
+      "as",
+      "you",
+      "do",
+      "at",
+      "this",
+      "but",
+      "his",
+      "by",
+      "from",
+      "they",
+      "we",
+      "say",
+      "her",
+      "she",
+      "or",
+      "an",
+      "will",
+      "my",
+      "one",
+      "all",
+      "would",
+      "there",
+      "their",
+      "what",
+      "so",
+      "up",
+      "out",
+      "if",
+      "about",
+      "who",
+      "get",
+      "which",
+      "go",
+      "me",
+      "when",
+      "make",
+      "can",
+      "like",
+      "time",
+      "no",
+      "just",
+      "him",
+      "know",
+      "take",
+      "into",
+      "year",
+      "your",
+      "some",
+      "could",
+      "them",
+      "see",
+      "other",
+      "than",
+      "then",
+      "now",
+      "look",
+      "only",
+      "come",
+      "its",
+      "over",
+      "also",
+      "back",
+      "after",
+      "use",
+      "two",
+      "how",
+      "our",
+      "first",
+      "way",
+      "even",
+      "new",
+      "want",
+      "because",
+      "any",
+      "these",
+      "give",
+      "day",
+      "most",
+      "us",
+      "should",
+      "been",
+      "has",
+      "was",
+      "are"
+    ]);
+    return stopWords.has(word);
+  }
+  updateAvgDocLength() {
+    if (this.documentLengths.size === 0) {
+      this.avgDocLength = 0;
+      return;
+    }
+    const total = Array.from(this.documentLengths.values()).reduce((a, b) => a + b, 0);
+    this.avgDocLength = total / this.documentLengths.size;
+  }
+};
+
+// src/memory/issue-store.ts
+async function storeIssues(issues, project, workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const memoryDir = join2(getTrieDirectory(projectDir), "memory");
+  await mkdir2(memoryDir, { recursive: true });
+  const stored = [];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const seenHashes = /* @__PURE__ */ new Set();
+  let duplicates = 0;
+  for (const issue of issues) {
+    const hash = hashIssue(issue);
+    if (seenHashes.has(hash)) {
+      duplicates++;
+      continue;
+    }
+    seenHashes.add(hash);
+    const storedIssue = {
+      id: issue.id,
+      hash,
+      severity: issue.severity,
+      issue: issue.issue,
+      fix: issue.fix,
+      file: issue.file,
+      line: issue.line,
+      agent: issue.agent,
+      category: issue.category,
+      timestamp: now,
+      project,
+      resolved: false,
+      resolvedAt: void 0
+    };
+    stored.push(storedIssue);
+  }
+  await appendToDailyLog(stored, projectDir);
+  await appendIssuesToLedger(stored, projectDir);
+  const dedupedCount = await updateIssueIndex(stored, projectDir);
+  return { stored: dedupedCount, duplicates: duplicates + (stored.length - dedupedCount) };
+}
+async function searchIssues(query, options = {}) {
+  const projectDir = options.workDir || getWorkingDirectory(void 0, true);
+  const limit = options.limit || 10;
+  const allIssues = await loadIssueIndex(projectDir);
+  if (allIssues.length === 0) {
+    return [];
+  }
+  const filteredIssues = allIssues.filter((issue) => {
+    if (options.project && issue.project !== options.project) return false;
+    if (options.severity && !options.severity.includes(issue.severity)) return false;
+    if (options.agent && issue.agent !== options.agent) return false;
+    if (!options.includeResolved && issue.resolved) return false;
+    return true;
+  });
+  if (filteredIssues.length === 0) {
+    return [];
+  }
+  const bm25 = new BM25Index();
+  const issueMap = /* @__PURE__ */ new Map();
+  for (const issue of filteredIssues) {
+    const searchText = `${issue.issue} ${issue.fix} ${issue.file} ${issue.agent} ${issue.category || ""} ${issue.severity}`;
+    bm25.addDocument({
+      id: issue.id,
+      text: searchText
+    });
+    issueMap.set(issue.id, issue);
+  }
+  const bm25Results = bm25.search(query, limit);
+  return bm25Results.map((result) => ({
+    issue: issueMap.get(result.id),
+    score: result.score,
+    matchType: "bm25"
+  }));
+}
+async function findSimilarIssues(issue, options = {}) {
+  const query = `${issue.issue} ${issue.fix} ${issue.agent}`;
+  const searchOptions = {
+    limit: (options.limit || 5) + 5,
+    // Get extra to account for filtering
+    includeResolved: true
+  };
+  if (options.workDir !== void 0) {
+    searchOptions.workDir = options.workDir;
+  }
+  const results = await searchIssues(query, searchOptions);
+  let filtered = results.filter((r) => r.issue.id !== issue.id);
+  if (options.excludeSameFile) {
+    filtered = filtered.filter((r) => r.issue.file !== issue.file);
+  }
+  return filtered.slice(0, options.limit || 5);
+}
+async function markIssueResolved(issueId, workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const index = await loadIssueIndex(projectDir);
+  const issue = index.find((i) => i.id === issueId);
+  if (!issue) return false;
+  issue.resolved = true;
+  issue.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await saveIssueIndex(index, projectDir);
+  return true;
+}
+async function autoResolveIssues(newIssueHashes, scannedFiles, workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const index = await loadIssueIndex(projectDir);
+  const scannedFileSet = new Set(scannedFiles.map((f) => f.replace(/\\/g, "/")));
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let resolvedCount = 0;
+  let stillActiveCount = 0;
+  for (const issue of index) {
+    if (issue.resolved) continue;
+    const normalizedFile = issue.file.replace(/\\/g, "/");
+    if (!scannedFileSet.has(normalizedFile)) {
+      stillActiveCount++;
+      continue;
+    }
+    if (!newIssueHashes.has(issue.hash)) {
+      issue.resolved = true;
+      issue.resolvedAt = now;
+      resolvedCount++;
+    } else {
+      stillActiveCount++;
+    }
+  }
+  if (resolvedCount > 0) {
+    await saveIssueIndex(index, projectDir);
+  }
+  return { resolved: resolvedCount, stillActive: stillActiveCount };
+}
+function getIssueHash(issue) {
+  return hashIssue(issue);
+}
+async function getMemoryStats(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const index = await loadIssueIndex(projectDir);
+  const historical = await getHistoricalInsights(projectDir);
+  const MAX_ISSUES = 1e4;
+  const uniqueHashes = new Set(index.map((i) => i.hash));
+  const stats = {
+    totalIssues: index.length,
+    activeIssues: 0,
+    issuesByAgent: {},
+    issuesBySeverity: {},
+    activeIssuesBySeverity: {},
+    oldestIssue: void 0,
+    newestIssue: void 0,
+    resolvedCount: 0,
+    historicalIssues: historical.totalHistoricalIssues,
+    improvementTrend: historical.improvementTrend,
+    capacityInfo: {
+      current: index.length,
+      max: MAX_ISSUES,
+      percentFull: Math.round(index.length / MAX_ISSUES * 100),
+      isAtCap: index.length >= MAX_ISSUES
+    },
+    deduplicationStats: {
+      duplicatesAvoided: index.length - uniqueHashes.size,
+      uniquePatterns: uniqueHashes.size
+    }
+  };
+  for (const issue of index) {
+    stats.issuesByAgent[issue.agent] = (stats.issuesByAgent[issue.agent] || 0) + 1;
+    stats.issuesBySeverity[issue.severity] = (stats.issuesBySeverity[issue.severity] || 0) + 1;
+    if (issue.resolved) {
+      stats.resolvedCount++;
+    } else {
+      stats.activeIssues++;
+      stats.activeIssuesBySeverity[issue.severity] = (stats.activeIssuesBySeverity[issue.severity] || 0) + 1;
+    }
+  }
+  if (index.length > 0) {
+    const sorted = [...index].sort(
+      (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+    );
+    const oldest = sorted[0]?.timestamp;
+    const newest = sorted[sorted.length - 1]?.timestamp;
+    if (oldest !== void 0) {
+      stats.oldestIssue = oldest;
+    }
+    if (newest !== void 0) {
+      stats.newestIssue = newest;
+    }
+  }
+  return stats;
+}
+async function getRecentIssues(options = {}) {
+  const projectDir = options.workDir || getWorkingDirectory(void 0, true);
+  const index = await loadIssueIndex(projectDir);
+  const limit = options.limit || 20;
+  const daysBack = options.daysBack || 7;
+  const includeResolved = options.includeResolved ?? false;
+  const cutoff = /* @__PURE__ */ new Date();
+  cutoff.setDate(cutoff.getDate() - daysBack);
+  return index.filter((i) => {
+    if (new Date(i.timestamp) < cutoff) return false;
+    if (!includeResolved && i.resolved) return false;
+    return true;
+  }).sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()).slice(0, limit);
+}
+async function purgeIssues(strategy, options = {}) {
+  const projectDir = options.workDir || getWorkingDirectory(void 0, true);
+  const index = await loadIssueIndex(projectDir);
+  const originalCount = index.length;
+  let remaining = [];
+  switch (strategy) {
+    case "smart":
+      const thirtyDaysAgo = /* @__PURE__ */ new Date();
+      thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+      remaining = index.filter((i) => {
+        const isRecent = new Date(i.timestamp) >= thirtyDaysAgo;
+        const isImportant = ["critical", "high"].includes(i.severity);
+        const isUnresolved = !i.resolved;
+        return isRecent || isImportant || isUnresolved;
+      });
+      break;
+    case "resolved":
+      remaining = index.filter((i) => !i.resolved);
+      break;
+    case "old":
+      const daysOld = options.daysOld || 90;
+      const cutoffDate = /* @__PURE__ */ new Date();
+      cutoffDate.setDate(cutoffDate.getDate() - daysOld);
+      remaining = index.filter((i) => new Date(i.timestamp) >= cutoffDate);
+      break;
+    case "all":
+      remaining = [];
+      break;
+  }
+  await saveIssueIndex(remaining, projectDir);
+  return {
+    removed: originalCount - remaining.length,
+    remaining: remaining.length,
+    strategy
+  };
+}
+async function getDailyLogs(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const memoryDir = join2(getTrieDirectory(projectDir), "memory");
+  try {
+    if (!existsSync2(memoryDir)) return [];
+    const files = await readdir(memoryDir);
+    return files.filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort().reverse();
+  } catch {
+    return [];
+  }
+}
+async function appendToDailyLog(issues, projectDir) {
+  const memoryDir = join2(getTrieDirectory(projectDir), "memory");
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const logPath = join2(memoryDir, `${today}.md`);
+  let content = "";
+  try {
+    if (existsSync2(logPath)) {
+      content = await readFile2(logPath, "utf-8");
+    } else {
+      content = `# Issue Log: ${today}
+
+`;
+    }
+  } catch {
+    content = `# Issue Log: ${today}
+
+`;
+  }
+  const time = (/* @__PURE__ */ new Date()).toTimeString().split(" ")[0];
+  const newEntries = issues.map(
+    (i) => `## [${time}] ${i.severity.toUpperCase()}: ${i.issue.slice(0, 80)}${i.issue.length > 80 ? "..." : ""}
+- **File:** \`${i.file}\`${i.line ? `:${i.line}` : ""}
+- **Agent:** ${i.agent}
+- **Fix:** ${i.fix.slice(0, 200)}${i.fix.length > 200 ? "..." : ""}
+`
+  ).join("\n");
+  content += newEntries + "\n";
+  await writeFile(logPath, content);
+}
+async function loadIssueIndex(projectDir) {
+  const indexPath = join2(getTrieDirectory(projectDir), "memory", "issues.json");
+  try {
+    if (existsSync2(indexPath)) {
+      const content = await readFile2(indexPath, "utf-8");
+      const result = safeParseAndValidate(content, IssueIndexSchema);
+      if (result.success) {
+        return result.data;
+      }
+      console.error(`   Issue index corrupted: ${result.error}`);
+      const backupManager = new BackupManager(indexPath);
+      if (await backupManager.recoverFromBackup()) {
+        console.error("   \u2705 Recovered from backup");
+        const recovered = await readFile2(indexPath, "utf-8");
+        const recoveredResult = safeParseAndValidate(recovered, IssueIndexSchema);
+        if (recoveredResult.success) {
+          return recoveredResult.data;
+        }
+      }
+      console.error("   No valid backup found, starting fresh");
+    }
+  } catch {
+  }
+  return [];
+}
+async function updateIssueIndex(newIssues, projectDir) {
+  const memoryDir = join2(getTrieDirectory(projectDir), "memory");
+  await mkdir2(memoryDir, { recursive: true });
+  let existing = await loadIssueIndex(projectDir);
+  const hashSet = new Set(existing.map((i) => i.hash));
+  const toAdd = newIssues.filter((i) => !hashSet.has(i.hash));
+  const dedupedCount = toAdd.length;
+  existing = [...existing, ...toAdd];
+  if (existing.length > 500) {
+    const { summary, remaining } = await compactOldIssues(existing, {
+      keepDays: 30,
+      minIssuesToCompact: 100
+    });
+    if (summary) {
+      await saveCompactedSummary(summary, projectDir);
+      existing = remaining;
+    }
+  }
+  if (existing.length > 1e4) {
+    existing = intelligentPrune(existing, 1e4);
+  }
+  await saveIssueIndex(existing, projectDir);
+  return dedupedCount;
+}
+function intelligentPrune(issues, targetCount) {
+  const severityWeight = {
+    critical: 100,
+    high: 50,
+    moderate: 20,
+    low: 10,
+    info: 5
+  };
+  const scored = issues.map((issue) => {
+    const ageInDays = (Date.now() - new Date(issue.timestamp).getTime()) / (1e3 * 60 * 60 * 24);
+    const recencyScore = Math.max(0, 100 - ageInDays * 2);
+    const severityScore = severityWeight[issue.severity] || 10;
+    const resolvedPenalty = issue.resolved ? -50 : 0;
+    return {
+      issue,
+      score: recencyScore + severityScore + resolvedPenalty
+    };
+  });
+  return scored.sort((a, b) => b.score - a.score).slice(0, targetCount).map((s) => s.issue);
+}
+async function saveIssueIndex(issues, projectDir) {
+  const memoryDir = join2(getTrieDirectory(projectDir), "memory");
+  await mkdir2(memoryDir, { recursive: true });
+  const indexPath = join2(memoryDir, "issues.json");
+  const backupManager = new BackupManager(indexPath);
+  await backupManager.createBackup();
+  await atomicWriteJSON(indexPath, issues);
+}
+function hashIssue(issue) {
+  const content = `${issue.issue}|${issue.file}|${issue.severity}|${issue.agent}`;
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+
+export {
+  getHistoricalInsights,
+  storeIssues,
+  searchIssues,
+  findSimilarIssues,
+  markIssueResolved,
+  autoResolveIssues,
+  getIssueHash,
+  getMemoryStats,
+  getRecentIssues,
+  purgeIssues,
+  getDailyLogs
+};
+//# sourceMappingURL=chunk-55DOQNHJ.js.map