@triedotdev/mcp 1.0.62 → 1.0.64

package/dist/chunk-TSHZQKCM.js

@@ -0,0 +1,933 @@
+import {
+  getWorkingDirectory
+} from "./chunk-KOFQ47YW.js";
+
+// src/memory/issue-store.ts
+import { mkdir as mkdir3, writeFile as writeFile2, readFile as readFile3, readdir as readdir2 } from "fs/promises";
+import { createHash } from "crypto";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } 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 as mkdir2, readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/utils/atomic-write.ts
+import { writeFile, rename, unlink, mkdir } from "fs/promises";
+import { randomBytes } from "crypto";
+import { dirname } from "path";
+async function atomicWriteFile(filePath, data, options = {}) {
+  const { createDir = true, encoding = "utf-8" } = options;
+  const tempSuffix = randomBytes(6).toString("hex");
+  const tempPath = `${filePath}.${tempSuffix}.tmp`;
+  try {
+    if (createDir) {
+      await mkdir(dirname(filePath), { recursive: true });
+    }
+    if (typeof data === "string") {
+      await writeFile(tempPath, data, { encoding });
+    } else {
+      await writeFile(tempPath, data);
+    }
+    await rename(tempPath, filePath);
+  } catch (error) {
+    try {
+      await unlink(tempPath);
+    } catch {
+    }
+    throw error;
+  }
+}
+async function atomicWriteJSON(filePath, data, options = {}) {
+  const { spaces = 2, ...writeOptions } = options;
+  const json = JSON.stringify(data, null, spaces);
+  await atomicWriteFile(filePath, json, writeOptions);
+}
+
+// src/utils/backup-manager.ts
+import { copyFile, readdir, unlink as unlink2, readFile, stat } from "fs/promises";
+import { existsSync } from "fs";
+import { dirname as dirname2, basename, join } from "path";
+var BackupManager = class {
+  filePath;
+  maxBackups;
+  validator;
+  backupDir;
+  baseFileName;
+  constructor(filePath, options = {}) {
+    this.filePath = filePath;
+    this.maxBackups = options.maxBackups ?? 5;
+    this.validator = options.validator;
+    this.backupDir = dirname2(filePath);
+    this.baseFileName = basename(filePath);
+  }
+  /**
+   * Create a backup of the current file
+   * 
+   * @returns The backup file path, or null if source doesn't exist
+   */
+  async createBackup() {
+    if (!existsSync(this.filePath)) {
+      return null;
+    }
+    const timestamp = Date.now();
+    const backupPath = this.getBackupPath(timestamp);
+    await copyFile(this.filePath, backupPath);
+    await this.pruneOldBackups();
+    return backupPath;
+  }
+  /**
+   * List all backups sorted by timestamp (newest first)
+   */
+  async listBackups() {
+    if (!existsSync(this.backupDir)) {
+      return [];
+    }
+    const files = await readdir(this.backupDir);
+    const backupPattern = new RegExp(
+      `^${this.escapeRegex(this.baseFileName)}\\.backup\\.(\\d+)$`
+    );
+    const backups = [];
+    for (const file of files) {
+      const match = file.match(backupPattern);
+      if (match) {
+        const timestamp = parseInt(match[1], 10);
+        const backupPath = join(this.backupDir, file);
+        try {
+          const stats = await stat(backupPath);
+          backups.push({
+            path: backupPath,
+            timestamp,
+            size: stats.size
+          });
+        } catch {
+        }
+      }
+    }
+    return backups.sort((a, b) => b.timestamp - a.timestamp);
+  }
+  /**
+   * Find the first valid backup
+   * 
+   * Iterates through backups from newest to oldest,
+   * returning the first one that passes validation.
+   * 
+   * @returns Path to valid backup, or null if none found
+   */
+  async findValidBackup() {
+    const backups = await this.listBackups();
+    for (const backup of backups) {
+      if (await this.validateBackup(backup.path)) {
+        return backup.path;
+      }
+    }
+    return null;
+  }
+  /**
+   * Validate a backup file
+   * 
+   * If a custom validator was provided, uses that.
+   * Otherwise, attempts JSON parse for .json files.
+   * 
+   * @returns true if backup is valid
+   */
+  async validateBackup(backupPath) {
+    try {
+      const content = await readFile(backupPath, "utf-8");
+      if (this.validator) {
+        return this.validator(content);
+      }
+      if (this.filePath.endsWith(".json")) {
+        JSON.parse(content);
+        return true;
+      }
+      return content.length > 0;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Recover from the most recent valid backup
+   * 
+   * @returns true if recovery was successful
+   */
+  async recoverFromBackup() {
+    const validBackup = await this.findValidBackup();
+    if (!validBackup) {
+      return false;
+    }
+    await copyFile(validBackup, this.filePath);
+    return true;
+  }
+  /**
+   * Remove old backups beyond the max limit
+   */
+  async pruneOldBackups() {
+    const backups = await this.listBackups();
+    const toRemove = backups.slice(this.maxBackups);
+    for (const backup of toRemove) {
+      try {
+        await unlink2(backup.path);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Get the backup path for a given timestamp
+   */
+  getBackupPath(timestamp) {
+    return join(this.backupDir, `${this.baseFileName}.backup.${timestamp}`);
+  }
+  /**
+   * Escape special regex characters in a string
+   */
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  /**
+   * Get the number of existing backups
+   */
+  async getBackupCount() {
+    const backups = await this.listBackups();
+    return backups.length;
+  }
+  /**
+   * Get the most recent backup timestamp
+   */
+  async getLatestBackupTime() {
+    const backups = await this.listBackups();
+    return backups[0]?.timestamp ?? null;
+  }
+  /**
+   * Delete all backups
+   */
+  async clearBackups() {
+    const backups = await this.listBackups();
+    let deleted = 0;
+    for (const backup of backups) {
+      try {
+        await unlink2(backup.path);
+        deleted++;
+      } catch {
+      }
+    }
+    return deleted;
+  }
+};
+
+// src/memory/validation.ts
+import { z } from "zod";
+var StoredIssueSchema = z.object({
+  id: z.string(),
+  hash: z.string(),
+  severity: z.string(),
+  issue: z.string(),
+  fix: z.string(),
+  file: z.string(),
+  line: z.number().optional(),
+  agent: z.string(),
+  category: z.string().optional(),
+  timestamp: z.string(),
+  project: z.string(),
+  resolved: z.boolean().optional(),
+  resolvedAt: z.string().optional()
+});
+var IssueIndexSchema = z.array(StoredIssueSchema);
+var FixAppliedSchema = z.object({
+  project: z.string(),
+  timestamp: z.string(),
+  fix: z.string()
+});
+var GlobalPatternSchema = z.object({
+  id: z.string(),
+  pattern: z.string(),
+  description: z.string(),
+  severity: z.string(),
+  agent: z.string(),
+  occurrences: z.number(),
+  projects: z.array(z.string()),
+  firstSeen: z.string(),
+  lastSeen: z.string(),
+  fixApplied: FixAppliedSchema.optional()
+});
+var GlobalPatternsIndexSchema = z.array(GlobalPatternSchema);
+var ProjectSummarySchema = z.object({
+  name: z.string(),
+  path: z.string(),
+  lastScan: z.string(),
+  healthScore: z.number(),
+  totalIssues: z.number(),
+  patterns: z.array(z.string())
+});
+var PatternSummarySchema = z.object({
+  pattern: z.string(),
+  count: z.number(),
+  severity: z.string(),
+  agent: z.string(),
+  exampleFix: z.string()
+});
+var HotFileSchema = z.object({
+  file: z.string(),
+  count: z.number()
+});
+var CompactedSummarySchema = z.object({
+  period: z.string(),
+  startDate: z.string(),
+  endDate: z.string(),
+  totalIssues: z.number(),
+  resolvedCount: z.number(),
+  bySeverity: z.record(z.string(), z.number()),
+  byAgent: z.record(z.string(), z.number()),
+  topPatterns: z.array(PatternSummarySchema),
+  hotFiles: z.array(HotFileSchema),
+  compactedAt: z.string()
+});
+var CompactedSummariesIndexSchema = z.array(CompactedSummarySchema);
+function safeParseAndValidate(content, schema) {
+  try {
+    const parsed = JSON.parse(content);
+    const result = schema.safeParse(parsed);
+    if (result.success) {
+      return { success: true, data: result.data };
+    }
+    return {
+      success: false,
+      error: `Validation failed: ${result.error.issues[0]?.message || "Unknown error"}`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `JSON parse failed: ${error instanceof Error ? error.message : "Unknown error"}`
+    };
+  }
+}
+
+// src/memory/compactor.ts
+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 = join2(projectDir, ".trie", "memory");
+  await mkdir2(memoryDir, { recursive: true });
+  const summaryPath = join2(memoryDir, "compacted-summaries.json");
+  let summaries = [];
+  try {
+    if (existsSync2(summaryPath)) {
+      const content = await readFile2(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 = join2(projectDir, ".trie", "memory", "compacted-summaries.json");
+  try {
+    if (existsSync2(summaryPath)) {
+      const content = await readFile2(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 readFile2(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 = join3(projectDir, ".trie", "memory");
+  await mkdir3(memoryDir, { recursive: true });
+  const stored = [];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const issue of issues) {
+    const hash = hashIssue(issue);
+    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 updateIssueIndex(stored, projectDir);
+  return stored.length;
+}
+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 getMemoryStats(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const index = await loadIssueIndex(projectDir);
+  const historical = await getHistoricalInsights(projectDir);
+  const stats = {
+    totalIssues: index.length,
+    issuesByAgent: {},
+    issuesBySeverity: {},
+    oldestIssue: void 0,
+    newestIssue: void 0,
+    resolvedCount: 0,
+    historicalIssues: historical.totalHistoricalIssues,
+    improvementTrend: historical.improvementTrend
+  };
+  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++;
+  }
+  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 cutoff = /* @__PURE__ */ new Date();
+  cutoff.setDate(cutoff.getDate() - daysBack);
+  return index.filter((i) => new Date(i.timestamp) >= cutoff).sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()).slice(0, limit);
+}
+async function getDailyLogs(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const memoryDir = join3(projectDir, ".trie", "memory");
+  try {
+    if (!existsSync3(memoryDir)) return [];
+    const files = await readdir2(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 = join3(projectDir, ".trie", "memory");
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const logPath = join3(memoryDir, `${today}.md`);
+  let content = "";
+  try {
+    if (existsSync3(logPath)) {
+      content = await readFile3(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 writeFile2(logPath, content);
+}
+async function loadIssueIndex(projectDir) {
+  const indexPath = join3(projectDir, ".trie", "memory", "issues.json");
+  try {
+    if (existsSync3(indexPath)) {
+      const content = await readFile3(indexPath, "utf-8");
+      const result = safeParseAndValidate(content, IssueIndexSchema);
+      if (result.success) {
+        return result.data;
+      }
+      console.error(`   \u26A0\uFE0F Issue index corrupted: ${result.error}`);
+      const backupManager = new BackupManager(indexPath);
+      if (await backupManager.recoverFromBackup()) {
+        console.error("   \u2705 Recovered from backup");
+        const recovered = await readFile3(indexPath, "utf-8");
+        const recoveredResult = safeParseAndValidate(recovered, IssueIndexSchema);
+        if (recoveredResult.success) {
+          return recoveredResult.data;
+        }
+      }
+      console.error("   \u274C No valid backup found, starting fresh");
+    }
+  } catch {
+  }
+  return [];
+}
+async function updateIssueIndex(newIssues, projectDir) {
+  const memoryDir = join3(projectDir, ".trie", "memory");
+  await mkdir3(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));
+  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 > 1e3) {
+    existing = existing.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()).slice(0, 1e3);
+  }
+  await saveIssueIndex(existing, projectDir);
+}
+async function saveIssueIndex(issues, projectDir) {
+  const memoryDir = join3(projectDir, ".trie", "memory");
+  await mkdir3(memoryDir, { recursive: true });
+  const indexPath = join3(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 {
+  atomicWriteFile,
+  atomicWriteJSON,
+  BackupManager,
+  GlobalPatternsIndexSchema,
+  safeParseAndValidate,
+  getHistoricalInsights,
+  storeIssues,
+  searchIssues,
+  findSimilarIssues,
+  markIssueResolved,
+  getMemoryStats,
+  getRecentIssues,
+  getDailyLogs
+};
+//# sourceMappingURL=chunk-TSHZQKCM.js.map