@triedotdev/mcp 1.0.136 → 1.0.138

package/dist/{chunk-JAKMZI5S.js → chunk-Z2P4WST6.js}

@@ -3,175 +3,20 @@ import {
   CompactedSummariesIndexSchema,
   IssueIndexSchema,
   safeParseAndValidate
-} from "./chunk-WS6OA7H6.js";
-import {
-  appendIssuesToLedger
-} from "./chunk-PEJEYWVR.js";
+} from "./chunk-4MJ52WBH.js";
 import {
   atomicWriteJSON
 } from "./chunk-43X6JBEM.js";
 import {
   getTrieDirectory,
   getWorkingDirectory
-} from "./chunk-45Y5TLQZ.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
-  };
-}
+} from "./chunk-SH7H3WRU.js";
 
 // 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";
+import { mkdir as mkdir3, writeFile, readFile as readFile3, readdir } from "fs/promises";
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
 
 // src/memory/bm25.ts
 var BM25Index = class _BM25Index {
@@ -402,11 +247,254 @@ var BM25Index = class _BM25Index {
   }
 };
 
-// src/memory/issue-store.ts
-async function storeIssues(issues, project, workDir) {
+// 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/ledger.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var LEDGER_FILENAME = "ledger.json";
+var GENESIS_HASH = "0".repeat(64);
+var LEDGER_VERSION = 1;
+async function appendIssuesToLedger(issues, workDir) {
+  if (issues.length === 0) return null;
   const projectDir = workDir || getWorkingDirectory(void 0, true);
   const memoryDir = join2(getTrieDirectory(projectDir), "memory");
   await mkdir2(memoryDir, { recursive: true });
+  const blocks = await loadLedger(projectDir);
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const entries = issues.map((issue) => ({
+    id: issue.id,
+    hash: issue.hash,
+    severity: issue.severity,
+    file: issue.file,
+    agent: issue.agent,
+    timestamp: issue.timestamp
+  }));
+  const previousBlock = blocks[blocks.length - 1];
+  const block = previousBlock && previousBlock.date === today ? previousBlock : createBlock(today, now, previousBlock?.blockHash ?? GENESIS_HASH);
+  if (block !== previousBlock) {
+    blocks.push(block);
+  }
+  block.entries = [...block.entries, ...entries];
+  block.merkleRoot = computeMerkleRoot(block.entries.map((entry) => entry.hash));
+  block.blockHash = computeBlockHash(block.previousHash, block.merkleRoot, block.date, block.version);
+  block.updatedAt = now;
+  await saveLedger(blocks, projectDir);
+  return block;
+}
+function computeMerkleRoot(hashes) {
+  if (hashes.length === 0) {
+    return sha256("");
+  }
+  let level = hashes.slice();
+  while (level.length > 1) {
+    const nextLevel = [];
+    for (let i = 0; i < level.length; i += 2) {
+      const left = level[i];
+      const right = level[i + 1] ?? left;
+      nextLevel.push(sha256(`${left}:${right}`));
+    }
+    level = nextLevel;
+  }
+  return level[0];
+}
+function computeBlockHash(previousHash, merkleRoot, date, version) {
+  return sha256(`${version}:${date}:${previousHash}:${merkleRoot}`);
+}
+function createBlock(date, now, previousHash) {
+  return {
+    version: LEDGER_VERSION,
+    date,
+    entries: [],
+    previousHash,
+    merkleRoot: "",
+    blockHash: "",
+    createdAt: now,
+    updatedAt: now
+  };
+}
+async function loadLedger(projectDir) {
+  const ledgerPath = join2(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
+  try {
+    if (!existsSync2(ledgerPath)) return [];
+    const content = await readFile2(ledgerPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!Array.isArray(parsed)) return [];
+    return parsed;
+  } catch {
+    return [];
+  }
+}
+async function getLedgerBlocks(workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  return loadLedger(projectDir);
+}
+async function saveLedger(blocks, projectDir) {
+  const ledgerPath = join2(getTrieDirectory(projectDir), "memory", LEDGER_FILENAME);
+  await atomicWriteJSON(ledgerPath, blocks);
+}
+function sha256(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+
+// src/memory/issue-store.ts
+async function storeIssues(issues, project, workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const memoryDir = join3(getTrieDirectory(projectDir), "memory");
+  await mkdir3(memoryDir, { recursive: true });
   const stored = [];
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const seenHashes = /* @__PURE__ */ new Set();
@@ -528,6 +616,27 @@ async function autoResolveIssues(newIssueHashes, scannedFiles, workDir) {
   }
   return { resolved: resolvedCount, stillActive: stillActiveCount };
 }
+async function resolveGoalViolation(file, goalDescription, workDir) {
+  const projectDir = workDir || getWorkingDirectory(void 0, true);
+  const index = await loadIssueIndex(projectDir);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let resolvedCount = 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;
+      resolvedCount++;
+    }
+  }
+  if (resolvedCount > 0) {
+    await saveIssueIndex(index, projectDir);
+  }
+  return resolvedCount;
+}
 function getIssueHash(issue) {
   return hashIssue(issue);
 }
@@ -636,9 +745,9 @@ async function purgeIssues(strategy, options = {}) {
 }
 async function getDailyLogs(workDir) {
   const projectDir = workDir || getWorkingDirectory(void 0, true);
-  const memoryDir = join2(getTrieDirectory(projectDir), "memory");
+  const memoryDir = join3(getTrieDirectory(projectDir), "memory");
   try {
-    if (!existsSync2(memoryDir)) return [];
+    if (!existsSync3(memoryDir)) return [];
     const files = await readdir(memoryDir);
     return files.filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f)).sort().reverse();
   } catch {
@@ -646,13 +755,13 @@ async function getDailyLogs(workDir) {
   }
 }
 async function appendToDailyLog(issues, projectDir) {
-  const memoryDir = join2(getTrieDirectory(projectDir), "memory");
+  const memoryDir = join3(getTrieDirectory(projectDir), "memory");
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  const logPath = join2(memoryDir, `${today}.md`);
+  const logPath = join3(memoryDir, `${today}.md`);
   let content = "";
   try {
-    if (existsSync2(logPath)) {
-      content = await readFile2(logPath, "utf-8");
+    if (existsSync3(logPath)) {
+      content = await readFile3(logPath, "utf-8");
     } else {
       content = `# Issue Log: ${today}
 
@@ -675,10 +784,10 @@ async function appendToDailyLog(issues, projectDir) {
   await writeFile(logPath, content);
 }
 async function loadIssueIndex(projectDir) {
-  const indexPath = join2(getTrieDirectory(projectDir), "memory", "issues.json");
+  const indexPath = join3(getTrieDirectory(projectDir), "memory", "issues.json");
   try {
-    if (existsSync2(indexPath)) {
-      const content = await readFile2(indexPath, "utf-8");
+    if (existsSync3(indexPath)) {
+      const content = await readFile3(indexPath, "utf-8");
       const result = safeParseAndValidate(content, IssueIndexSchema);
       if (result.success) {
         return result.data;
@@ -687,7 +796,7 @@ async function loadIssueIndex(projectDir) {
       const backupManager = new BackupManager(indexPath);
       if (await backupManager.recoverFromBackup()) {
         console.error("   \u2705 Recovered from backup");
-        const recovered = await readFile2(indexPath, "utf-8");
+        const recovered = await readFile3(indexPath, "utf-8");
         const recoveredResult = safeParseAndValidate(recovered, IssueIndexSchema);
         if (recoveredResult.success) {
           return recoveredResult.data;
@@ -700,8 +809,8 @@ async function loadIssueIndex(projectDir) {
   return [];
 }
 async function updateIssueIndex(newIssues, projectDir) {
-  const memoryDir = join2(getTrieDirectory(projectDir), "memory");
-  await mkdir2(memoryDir, { recursive: true });
+  const memoryDir = join3(getTrieDirectory(projectDir), "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));
@@ -744,29 +853,31 @@ function intelligentPrune(issues, targetCount) {
   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 memoryDir = join3(getTrieDirectory(projectDir), "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);
+  return createHash2("sha256").update(content).digest("hex").slice(0, 16);
 }
 
 export {
   getHistoricalInsights,
+  getLedgerBlocks,
   storeIssues,
   searchIssues,
   findSimilarIssues,
   markIssueResolved,
   autoResolveIssues,
+  resolveGoalViolation,
   getIssueHash,
   getMemoryStats,
   getRecentIssues,
   purgeIssues,
   getDailyLogs
 };
-//# sourceMappingURL=chunk-JAKMZI5S.js.map
+//# sourceMappingURL=chunk-Z2P4WST6.js.map