@triedotdev/mcp 1.0.168 → 1.0.170

package/dist/chunk-XE6KQRKZ.js

@@ -1,816 +0,0 @@
-import {
-  appendIssuesToLedger,
-  withFileLock
-} from "./chunk-ZJF5FTBX.js";
-import {
-  BackupManager,
-  CompactedSummariesIndexSchema,
-  IssueIndexSchema,
-  safeParseAndValidate
-} from "./chunk-EFWVF6TI.js";
-import {
-  atomicWriteJSON
-} from "./chunk-43X6JBEM.js";
-import {
-  getTrieDirectory,
-  getWorkingDirectory
-} from "./chunk-VVITXIHN.js";
-
-// src/memory/issue-store.ts
-import { mkdir as mkdir2, 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/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
-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,
-      ...issue.ledgerBlockHash && { ledgerBlockHash: issue.ledgerBlockHash }
-    };
-    stored.push(storedIssue);
-  }
-  const ledgerBlock = await appendIssuesToLedger(stored, projectDir);
-  if (ledgerBlock) {
-    for (const issue of stored) {
-      issue.ledgerBlockHash = ledgerBlock.blockHash;
-    }
-  }
-  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 memoryDir = join2(getTrieDirectory(projectDir), "memory");
-  const indexPath = join2(memoryDir, "issues.json");
-  return withFileLock(indexPath, async () => {
-    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 saveIssueIndexInternal(index, projectDir);
-    return true;
-  }, { timeout: 1e4 });
-}
-async function autoResolveIssues(newIssueHashes, scannedFiles, workDir) {
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const memoryDir = join2(getTrieDirectory(projectDir), "memory");
-  const indexPath = join2(memoryDir, "issues.json");
-  return withFileLock(indexPath, async () => {
-    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 saveIssueIndexInternal(index, projectDir);
-    }
-    return { resolved: resolvedCount, stillActive: stillActiveCount };
-  }, { timeout: 15e3 });
-}
-async function resolveGoalViolation(file, goalDescription, workDir) {
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const memoryDir = join2(getTrieDirectory(projectDir), "memory");
-  const indexPath = join2(memoryDir, "issues.json");
-  let resolvedCount = await withFileLock(indexPath, async () => {
-    const index = await loadIssueIndex(projectDir);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    let count = 0;
-    for (const issue of index) {
-      if (issue.resolved) continue;
-      if (issue.agent !== "goal-violation") continue;
-      const normalizedFile = issue.file.replace(/\\/g, "/");
-      const normalizedTarget = file.replace(/\\/g, "/");
-      if (normalizedFile === normalizedTarget && issue.issue.includes(`Goal "${goalDescription}"`)) {
-        issue.resolved = true;
-        issue.resolvedAt = now;
-        count++;
-      }
-    }
-    if (count > 0) {
-      await saveIssueIndexInternal(index, projectDir);
-    }
-    return count;
-  }, { timeout: 1e4 });
-  try {
-    const { getStorage } = await import("./tiered-storage-Z3YCR465.js");
-    const storage = getStorage(projectDir);
-    await storage.initialize();
-    const nudgeResolved = await storage.resolveNudgesForGoalViolation(file, goalDescription, workDir);
-    if (nudgeResolved > 0) {
-      console.debug(`[IssueStore] Auto-resolved ${nudgeResolved} nudge(s) for fixed goal violation`);
-      resolvedCount += nudgeResolved;
-    }
-  } catch (e) {
-    console.debug("[IssueStore] Nudge resolution failed (non-fatal):", e);
-  }
-  return resolvedCount;
-}
-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 memoryDir = join2(getTrieDirectory(projectDir), "memory");
-  const indexPath = join2(memoryDir, "issues.json");
-  return withFileLock(indexPath, async () => {
-    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 saveIssueIndexInternal(remaining, projectDir);
-    return {
-      removed: originalCount - remaining.length,
-      remaining: remaining.length,
-      strategy
-    };
-  }, { timeout: 1e4 });
-}
-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 getIssueLedgerEntry(issue, workDir) {
-  if (!issue.ledgerBlockHash) return null;
-  const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const { getLedgerBlocks } = await import("./ledger-TWZTGDFA.js");
-  const blocks = await getLedgerBlocks(projectDir);
-  const block = blocks.find((b) => b.blockHash === issue.ledgerBlockHash);
-  if (!block) return null;
-  const entry = block.entries.find((e) => e.hash === issue.hash);
-  if (!entry) return null;
-  return { block, entry };
-}
-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;
-      }
-      const errorMsg = "success" in result && !result.success ? result.error : "Unknown validation error";
-      console.error(`   Issue index corrupted: ${errorMsg}`);
-      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 });
-  const indexPath = join2(memoryDir, "issues.json");
-  return withFileLock(indexPath, async () => {
-    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 saveIssueIndexInternal(existing, projectDir);
-    return dedupedCount;
-  }, { timeout: 15e3 });
-}
-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 saveIssueIndexInternal(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,
-  resolveGoalViolation,
-  getIssueHash,
-  getMemoryStats,
-  getRecentIssues,
-  purgeIssues,
-  getDailyLogs,
-  getIssueLedgerEntry
-};
-//# sourceMappingURL=chunk-XE6KQRKZ.js.map