@triedotdev/mcp 1.0.94 → 1.0.97

package/dist/chunk-NIASHOAB.js

@@ -0,0 +1,1304 @@
+import {
+  scanForVulnerabilities
+} from "./chunk-F4NJ4CBP.js";
+import {
+  scanForVibeCodeIssues
+} from "./chunk-IXO4G4D3.js";
+import {
+  BackupManager,
+  GlobalPatternsIndexSchema,
+  atomicWriteJSON,
+  safeParseAndValidate,
+  searchIssues
+} from "./chunk-JDHR5BDR.js";
+import {
+  getTrieDirectory,
+  getWorkingDirectory
+} from "./chunk-R4AAPFXC.js";
+
+// src/memory/global-memory.ts
+import { mkdir, writeFile, readFile, readdir } from "fs/promises";
+import { createHash } from "crypto";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var GLOBAL_TRIE_DIR = join(homedir(), ".trie");
+var GLOBAL_MEMORY_DIR = join(GLOBAL_TRIE_DIR, "memory");
+async function recordToGlobalMemory(issues, projectName, projectPath, healthScore = 0) {
+  await mkdir(GLOBAL_MEMORY_DIR, { recursive: true });
+  await mkdir(join(GLOBAL_MEMORY_DIR, "projects"), { recursive: true });
+  const patterns = await loadGlobalPatterns();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const issue of issues) {
+    const patternId = extractPatternId(issue);
+    const existing = patterns.find((p) => p.id === patternId);
+    if (existing) {
+      existing.occurrences++;
+      existing.lastSeen = now;
+      if (!existing.projects.includes(projectName)) {
+        existing.projects.push(projectName);
+      }
+    } else {
+      patterns.push({
+        id: patternId,
+        pattern: issue.issue.slice(0, 200),
+        description: issue.fix.slice(0, 200),
+        severity: issue.severity,
+        agent: issue.agent,
+        occurrences: 1,
+        projects: [projectName],
+        firstSeen: now,
+        lastSeen: now
+      });
+    }
+  }
+  await saveGlobalPatterns(patterns);
+  const summaryPath = join(GLOBAL_MEMORY_DIR, "projects", `${sanitizeName(projectName)}.json`);
+  const summary = {
+    name: projectName,
+    path: projectPath,
+    lastScan: now,
+    healthScore,
+    totalIssues: issues.length,
+    patterns: [...new Set(issues.map((i) => extractPatternId(i)))]
+  };
+  await atomicWriteJSON(summaryPath, summary);
+}
+async function findCrossProjectPatterns(minOccurrences = 2) {
+  const patterns = await loadGlobalPatterns();
+  return patterns.filter((p) => p.projects.length >= minOccurrences).sort((a, b) => b.occurrences - a.occurrences);
+}
+async function listTrackedProjects() {
+  const projectsDir = join(GLOBAL_MEMORY_DIR, "projects");
+  try {
+    if (!existsSync(projectsDir)) return [];
+    const files = await readdir(projectsDir);
+    const summaries = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        const content = await readFile(join(projectsDir, file), "utf-8");
+        summaries.push(JSON.parse(content));
+      } catch {
+      }
+    }
+    return summaries.sort(
+      (a, b) => new Date(b.lastScan).getTime() - new Date(a.lastScan).getTime()
+    );
+  } catch {
+    return [];
+  }
+}
+async function getGlobalMemoryStats() {
+  const patterns = await loadGlobalPatterns();
+  const projects = await listTrackedProjects();
+  const MAX_PATTERNS = 500;
+  const patternsByAgent = {};
+  for (const pattern of patterns) {
+    patternsByAgent[pattern.agent] = (patternsByAgent[pattern.agent] || 0) + 1;
+  }
+  const totalOccurrences = patterns.reduce((sum, p) => sum + p.occurrences, 0);
+  const avgOccurrences = patterns.length > 0 ? totalOccurrences / patterns.length : 0;
+  return {
+    totalPatterns: patterns.length,
+    crossProjectPatterns: patterns.filter((p) => p.projects.length >= 2).length,
+    trackedProjects: projects.length,
+    totalOccurrences,
+    fixedPatterns: patterns.filter((p) => p.fixApplied).length,
+    patternsByAgent,
+    capacityInfo: {
+      current: patterns.length,
+      max: MAX_PATTERNS,
+      percentFull: Math.round(patterns.length / MAX_PATTERNS * 100),
+      isAtCap: patterns.length >= MAX_PATTERNS
+    },
+    deduplicationStats: {
+      uniquePatterns: patterns.length,
+      averageOccurrences: Math.round(avgOccurrences * 10) / 10
+    }
+  };
+}
+async function updateGlobalMemoryMd() {
+  const patterns = await loadGlobalPatterns();
+  const crossProject = patterns.filter((p) => p.projects.length >= 2);
+  const projects = await listTrackedProjects();
+  const lines = [
+    "# Global Trie Memory",
+    "",
+    "> Auto-generated file tracking patterns across all your projects.",
+    `> Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "## Summary",
+    "",
+    `- **Projects tracked:** ${projects.length}`,
+    `- **Total patterns:** ${patterns.length}`,
+    `- **Cross-project patterns:** ${crossProject.length}`,
+    "",
+    "## Cross-Project Patterns",
+    "",
+    "These issues appear in multiple projects:",
+    ""
+  ];
+  for (const p of crossProject.slice(0, 20)) {
+    lines.push(
+      `### ${p.pattern.slice(0, 60)}${p.pattern.length > 60 ? "..." : ""}`,
+      "",
+      `- **Severity:** ${p.severity}`,
+      `- **Agent:** ${p.agent}`,
+      `- **Occurrences:** ${p.occurrences} across ${p.projects.length} projects`,
+      `- **Projects:** ${p.projects.slice(0, 5).join(", ")}${p.projects.length > 5 ? "..." : ""}`
+    );
+    if (p.fixApplied) {
+      lines.push(`- **Fixed in:** ${p.fixApplied.project} on ${p.fixApplied.timestamp.split("T")[0]}`);
+    } else {
+      lines.push("- **Status:** Not fixed");
+    }
+    lines.push("");
+  }
+  lines.push(
+    "## Tracked Projects",
+    "",
+    "| Project | Last Scan | Health | Issues |",
+    "|---------|-----------|--------|--------|"
+  );
+  for (const p of projects.slice(0, 20)) {
+    lines.push(`| ${p.name} | ${p.lastScan.split("T")[0]} | ${p.healthScore}% | ${p.totalIssues} |`);
+  }
+  lines.push("", "---", "", "*This file is auto-generated by Trie. Do not edit manually.*");
+  await mkdir(GLOBAL_MEMORY_DIR, { recursive: true });
+  await writeFile(join(GLOBAL_MEMORY_DIR, "GLOBAL_MEMORY.md"), lines.join("\n"));
+}
+async function searchGlobalPatterns(query, options = {}) {
+  const patterns = await loadGlobalPatterns();
+  const limit = options.limit || 10;
+  const queryTerms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
+  const scored = patterns.filter((p) => {
+    if (options.severity && !options.severity.includes(p.severity)) return false;
+    if (options.agent && p.agent !== options.agent) return false;
+    return true;
+  }).map((p) => {
+    const text = `${p.pattern} ${p.description} ${p.agent}`.toLowerCase();
+    let score = 0;
+    for (const term of queryTerms) {
+      if (text.includes(term)) score++;
+    }
+    return { pattern: p, score };
+  }).filter((s) => s.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
+  return scored.map((s) => s.pattern);
+}
+async function loadGlobalPatterns() {
+  const patternsPath = join(GLOBAL_MEMORY_DIR, "global-patterns.json");
+  try {
+    if (existsSync(patternsPath)) {
+      const content = await readFile(patternsPath, "utf-8");
+      const result = safeParseAndValidate(content, GlobalPatternsIndexSchema);
+      if (result.success) {
+        return result.data;
+      }
+      const backupManager = new BackupManager(patternsPath);
+      if (await backupManager.recoverFromBackup()) {
+        const recovered = await readFile(patternsPath, "utf-8");
+        const recoveredResult = safeParseAndValidate(recovered, GlobalPatternsIndexSchema);
+        if (recoveredResult.success) {
+          return recoveredResult.data;
+        }
+      }
+    }
+  } catch {
+  }
+  return [];
+}
+async function saveGlobalPatterns(patterns) {
+  await mkdir(GLOBAL_MEMORY_DIR, { recursive: true });
+  const patternsPath = join(GLOBAL_MEMORY_DIR, "global-patterns.json");
+  const patternMap = /* @__PURE__ */ new Map();
+  for (const pattern of patterns) {
+    const existing = patternMap.get(pattern.id);
+    if (existing) {
+      existing.occurrences += pattern.occurrences;
+      for (const proj of pattern.projects) {
+        if (!existing.projects.includes(proj)) {
+          existing.projects.push(proj);
+        }
+      }
+      existing.lastSeen = pattern.lastSeen > existing.lastSeen ? pattern.lastSeen : existing.lastSeen;
+    } else {
+      patternMap.set(pattern.id, pattern);
+    }
+  }
+  const deduplicated = Array.from(patternMap.values());
+  const pruned = intelligentPruneGlobalPatterns(deduplicated, 500);
+  const backupManager = new BackupManager(patternsPath);
+  await backupManager.createBackup();
+  await atomicWriteJSON(patternsPath, pruned);
+}
+function intelligentPruneGlobalPatterns(patterns, targetCount) {
+  if (patterns.length <= targetCount) {
+    return patterns;
+  }
+  const severityWeight = {
+    critical: 100,
+    high: 50,
+    moderate: 20,
+    low: 10,
+    info: 5
+  };
+  const scored = patterns.map((pattern) => {
+    const ageInDays = (Date.now() - new Date(pattern.lastSeen).getTime()) / (1e3 * 60 * 60 * 24);
+    const recencyScore = Math.max(0, 100 - ageInDays * 2);
+    const severityScore = severityWeight[pattern.severity] || 10;
+    const crossProjectBonus = (pattern.projects.length - 1) * 30;
+    const fixedBonus = pattern.fixApplied ? 20 : 0;
+    const occurrenceScore = Math.min(pattern.occurrences * 2, 100);
+    return {
+      pattern,
+      score: recencyScore + severityScore + crossProjectBonus + fixedBonus + occurrenceScore
+    };
+  });
+  return scored.sort((a, b) => b.score - a.score).slice(0, targetCount).map((s) => s.pattern);
+}
+function extractPatternId(issue) {
+  const normalized = issue.issue.toLowerCase().replace(/`[^`]+`/g, "CODE").replace(/\b\d+\b/g, "N").replace(/['"]/g, "").slice(0, 100);
+  const hash = createHash("sha256").update(normalized).digest("hex").slice(0, 12);
+  return `${issue.agent}-${issue.severity}-${hash}`;
+}
+function sanitizeName(name) {
+  return name.replace(/[^a-zA-Z0-9-_]/g, "-").toLowerCase();
+}
+
+// src/ai/client.ts
+import Anthropic from "@anthropic-ai/sdk";
+import { readFileSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var clientInstance = null;
+var apiKeyChecked = false;
+var apiKeyAvailable = false;
+function isAIAvailable() {
+  if (!apiKeyChecked) {
+    checkAPIKey();
+  }
+  return apiKeyAvailable;
+}
+function checkAPIKey() {
+  apiKeyChecked = true;
+  const envApiKey = process.env.ANTHROPIC_API_KEY;
+  if (envApiKey && envApiKey.length > 10) {
+    apiKeyAvailable = true;
+    return;
+  }
+  try {
+    const workDir = getWorkingDirectory(void 0, true);
+    const configPath = join2(getTrieDirectory(workDir), "config.json");
+    if (existsSync2(configPath)) {
+      const configContent = readFileSync(configPath, "utf-8");
+      const config = JSON.parse(configContent);
+      if (config.apiKeys?.anthropic && config.apiKeys.anthropic.length > 10) {
+        process.env.ANTHROPIC_API_KEY = config.apiKeys.anthropic;
+        apiKeyAvailable = true;
+        return;
+      }
+    }
+  } catch {
+  }
+  try {
+    const workDir = getWorkingDirectory(void 0, true);
+    const envFiles = [".env", ".env.local", ".env.production"];
+    for (const envFile of envFiles) {
+      const envPath = join2(workDir, envFile);
+      if (existsSync2(envPath)) {
+        const envContent = readFileSync(envPath, "utf-8");
+        const lines = envContent.split("\n");
+        for (const line of lines) {
+          const match = line.match(/^\s*ANTHROPIC_API_KEY\s*=\s*(.+)$/);
+          if (match && match[1]) {
+            const key = match[1].trim().replace(/^["']|["']$/g, "");
+            if (key.length > 10) {
+              process.env.ANTHROPIC_API_KEY = key;
+              apiKeyAvailable = true;
+              return;
+            }
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  apiKeyAvailable = false;
+}
+function tryGetClient() {
+  if (!isAIAvailable()) {
+    return null;
+  }
+  if (!clientInstance) {
+    clientInstance = new Anthropic();
+  }
+  return clientInstance;
+}
+async function runAIAnalysis(request) {
+  const client = tryGetClient();
+  if (!client) {
+    return {
+      success: false,
+      content: "",
+      error: "AI not available - ANTHROPIC_API_KEY not set"
+    };
+  }
+  try {
+    const response = await client.messages.create({
+      model: "claude-sonnet-4-20250514",
+      max_tokens: request.maxTokens || 4096,
+      temperature: request.temperature ?? 0.3,
+      system: request.systemPrompt,
+      messages: [
+        {
+          role: "user",
+          content: request.userPrompt
+        }
+      ]
+    });
+    const textContent = response.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+    return {
+      success: true,
+      content: textContent,
+      tokensUsed: {
+        input: response.usage.input_tokens,
+        output: response.usage.output_tokens
+      }
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage.includes("authentication") || errorMessage.includes("API key")) {
+      return {
+        success: false,
+        content: "",
+        error: "Invalid API key. Check your ANTHROPIC_API_KEY."
+      };
+    }
+    if (errorMessage.includes("rate limit")) {
+      return {
+        success: false,
+        content: "",
+        error: "Rate limited. Try again in a moment."
+      };
+    }
+    return {
+      success: false,
+      content: "",
+      error: `AI analysis failed: ${errorMessage}`
+    };
+  }
+}
+
+// src/storage/tiered-storage.ts
+import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join3 } from "path";
+import Database from "better-sqlite3";
+var TieredStorage = class {
+  workDir;
+  hotCache = /* @__PURE__ */ new Map();
+  warmDb = null;
+  constructor(workDir) {
+    this.workDir = workDir;
+  }
+  /**
+   * Initialize storage directories and database
+   */
+  async initialize() {
+    const trieDir = getTrieDirectory(this.workDir);
+    await mkdir2(join3(trieDir, "hot"), { recursive: true });
+    await mkdir2(join3(trieDir, "warm"), { recursive: true });
+    await mkdir2(join3(trieDir, "cold"), { recursive: true });
+    const dbPath = join3(trieDir, "warm", "decisions.db");
+    this.warmDb = new Database(dbPath);
+    this.warmDb.exec(`
+      CREATE TABLE IF NOT EXISTS decisions (
+        id TEXT PRIMARY KEY,
+        decision TEXT NOT NULL,
+        context TEXT NOT NULL,
+        reasoning TEXT,
+        timestamp TEXT NOT NULL,
+        who TEXT,
+        files TEXT NOT NULL, -- JSON array
+        tags TEXT NOT NULL, -- JSON array
+        expandedTags TEXT, -- JSON array (with synonyms)
+        relatedTo TEXT, -- JSON array
+        tradeoffs TEXT, -- JSON array
+        status TEXT NOT NULL,
+        supersededBy TEXT,
+        dependencies TEXT, -- JSON array (npm packages, services)
+        codebaseArea TEXT, -- JSON array (frontend, backend, auth, etc.)
+        domain TEXT, -- JSON array (payments, compliance, etc.)
+        lastAccessed TEXT NOT NULL,
+        accessCount INTEGER DEFAULT 0
+      );
+
+      CREATE TABLE IF NOT EXISTS facts (
+        id TEXT PRIMARY KEY,
+        fact TEXT NOT NULL,
+        source TEXT NOT NULL,
+        timestamp TEXT NOT NULL,
+        tags TEXT NOT NULL, -- JSON array
+        expandedTags TEXT, -- JSON array (with synonyms)
+        relatedDecisions TEXT, -- JSON array
+        confidence REAL NOT NULL,
+        lastAccessed TEXT NOT NULL,
+        accessCount INTEGER DEFAULT 0
+      );
+
+      CREATE TABLE IF NOT EXISTS blockers (
+        id TEXT PRIMARY KEY,
+        blocker TEXT NOT NULL,
+        impact TEXT NOT NULL,
+        affectedAreas TEXT NOT NULL, -- JSON array
+        timestamp TEXT NOT NULL,
+        resolvedAt TEXT,
+        resolution TEXT,
+        tags TEXT NOT NULL, -- JSON array
+        expandedTags TEXT, -- JSON array (with synonyms)
+        lastAccessed TEXT NOT NULL,
+        accessCount INTEGER DEFAULT 0
+      );
+
+      CREATE TABLE IF NOT EXISTS questions (
+        id TEXT PRIMARY KEY,
+        question TEXT NOT NULL,
+        context TEXT NOT NULL,
+        timestamp TEXT NOT NULL,
+        answeredAt TEXT,
+        answer TEXT,
+        relatedDecisions TEXT, -- JSON array
+        tags TEXT NOT NULL, -- JSON array
+        expandedTags TEXT, -- JSON array (with synonyms)
+        lastAccessed TEXT NOT NULL,
+        accessCount INTEGER DEFAULT 0
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_decisions_tags ON decisions(tags);
+      CREATE INDEX IF NOT EXISTS idx_decisions_expanded ON decisions(expandedTags);
+      CREATE INDEX IF NOT EXISTS idx_decisions_timestamp ON decisions(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_decisions_status ON decisions(status);
+      CREATE INDEX IF NOT EXISTS idx_decisions_area ON decisions(codebaseArea);
+      CREATE INDEX IF NOT EXISTS idx_decisions_domain ON decisions(domain);
+      CREATE INDEX IF NOT EXISTS idx_facts_tags ON facts(tags);
+      CREATE INDEX IF NOT EXISTS idx_facts_expanded ON facts(expandedTags);
+      CREATE INDEX IF NOT EXISTS idx_blockers_impact ON blockers(impact);
+      CREATE INDEX IF NOT EXISTS idx_blockers_resolved ON blockers(resolvedAt);
+    `);
+  }
+  /**
+   * Store extracted signal with enriched metadata in warm storage
+   */
+  async storeSignal(signal, metadata) {
+    if (!this.warmDb) await this.initialize();
+    if (!this.warmDb) throw new Error("Database not initialized");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const decisionStmt = this.warmDb.prepare(`
+      INSERT OR REPLACE INTO decisions 
+      (id, decision, context, reasoning, timestamp, who, files, tags, expandedTags, relatedTo, tradeoffs, status, supersededBy, dependencies, codebaseArea, domain, lastAccessed, accessCount)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
+    `);
+    for (const dec of signal.decisions) {
+      decisionStmt.run(
+        dec.id,
+        dec.decision,
+        dec.context,
+        dec.reasoning || null,
+        dec.when,
+        dec.who || null,
+        JSON.stringify(dec.files),
+        JSON.stringify(dec.tags),
+        JSON.stringify(metadata?.expandedTags || []),
+        JSON.stringify(dec.relatedTo || []),
+        JSON.stringify(dec.tradeoffs || []),
+        dec.status,
+        dec.supersededBy || null,
+        JSON.stringify(metadata?.dependencies || []),
+        JSON.stringify(metadata?.codebaseArea || []),
+        JSON.stringify(metadata?.domain || []),
+        now
+      );
+    }
+    const factStmt = this.warmDb.prepare(`
+      INSERT OR REPLACE INTO facts
+      (id, fact, source, timestamp, tags, expandedTags, relatedDecisions, confidence, lastAccessed, accessCount)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
+    `);
+    for (const fact of signal.facts) {
+      factStmt.run(
+        fact.id,
+        fact.fact,
+        fact.source,
+        fact.when,
+        JSON.stringify(fact.tags),
+        JSON.stringify(metadata?.expandedTags || []),
+        JSON.stringify(fact.relatedDecisions || []),
+        fact.confidence,
+        now
+      );
+    }
+    const blockerStmt = this.warmDb.prepare(`
+      INSERT OR REPLACE INTO blockers
+      (id, blocker, impact, affectedAreas, timestamp, resolvedAt, resolution, tags, expandedTags, lastAccessed, accessCount)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
+    `);
+    for (const blocker of signal.blockers) {
+      blockerStmt.run(
+        blocker.id,
+        blocker.blocker,
+        blocker.impact,
+        JSON.stringify(blocker.affectedAreas),
+        blocker.when,
+        blocker.resolvedAt || null,
+        blocker.resolution || null,
+        JSON.stringify(blocker.tags),
+        JSON.stringify(metadata?.expandedTags || []),
+        now
+      );
+    }
+    const questionStmt = this.warmDb.prepare(`
+      INSERT OR REPLACE INTO questions
+      (id, question, context, timestamp, answeredAt, answer, relatedDecisions, tags, expandedTags, lastAccessed, accessCount)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0)
+    `);
+    for (const q of signal.questions) {
+      questionStmt.run(
+        q.id,
+        q.question,
+        q.context,
+        q.when,
+        q.answeredAt || null,
+        q.answer || null,
+        JSON.stringify(q.relatedDecisions || []),
+        JSON.stringify(q.tags),
+        JSON.stringify(metadata?.expandedTags || []),
+        now
+      );
+    }
+  }
+  /**
+   * Query decisions from warm storage with expanded tag matching
+   */
+  async queryDecisions(query) {
+    if (!this.warmDb) await this.initialize();
+    if (!this.warmDb) throw new Error("Database not initialized");
+    let sql = "SELECT * FROM decisions WHERE status = ?";
+    const params = ["active"];
+    if (query.tags && query.tags.length > 0) {
+      sql += " AND (" + query.tags.map(() => "(tags LIKE ? OR expandedTags LIKE ?)").join(" OR ") + ")";
+      for (const tag of query.tags) {
+        params.push(`%"${tag}"%`, `%"${tag}"%`);
+      }
+    }
+    if (query.filters?.codebaseArea) {
+      sql += " AND codebaseArea LIKE ?";
+      params.push(`%"${query.filters.codebaseArea}"%`);
+    }
+    if (query.filters?.domain) {
+      sql += " AND domain LIKE ?";
+      params.push(`%"${query.filters.domain}"%`);
+    }
+    if (query.timeWindow) {
+      if (query.timeWindow.start) {
+        sql += " AND timestamp >= ?";
+        params.push(query.timeWindow.start);
+      }
+      if (query.timeWindow.end) {
+        sql += " AND timestamp <= ?";
+        params.push(query.timeWindow.end);
+      }
+    }
+    sql += " ORDER BY timestamp DESC";
+    if (query.limit) {
+      sql += " LIMIT ?";
+      params.push(query.limit);
+    }
+    const rows = this.warmDb.prepare(sql).all(...params);
+    return rows.map((row) => ({
+      id: row.id,
+      decision: row.decision,
+      context: row.context,
+      reasoning: row.reasoning,
+      when: row.when,
+      who: row.who,
+      files: JSON.parse(row.files),
+      tags: JSON.parse(row.tags),
+      relatedTo: JSON.parse(row.relatedTo || "[]"),
+      tradeoffs: JSON.parse(row.tradeoffs || "[]"),
+      status: row.status,
+      supersededBy: row.supersededBy
+    }));
+  }
+  /**
+   * Query blockers from warm storage with expanded tag matching
+   */
+  async queryBlockers(query) {
+    if (!this.warmDb) await this.initialize();
+    if (!this.warmDb) throw new Error("Database not initialized");
+    let sql = "SELECT * FROM blockers WHERE resolvedAt IS NULL";
+    const params = [];
+    if (query.tags && query.tags.length > 0) {
+      sql += " AND (" + query.tags.map(() => "(tags LIKE ? OR expandedTags LIKE ?)").join(" OR ") + ")";
+      for (const tag of query.tags) {
+        params.push(`%"${tag}"%`, `%"${tag}"%`);
+      }
+    }
+    sql += ' ORDER BY CASE impact WHEN "critical" THEN 1 WHEN "high" THEN 2 WHEN "medium" THEN 3 ELSE 4 END, timestamp DESC';
+    if (query.limit) {
+      sql += " LIMIT ?";
+      params.push(query.limit);
+    }
+    const rows = this.warmDb.prepare(sql).all(...params);
+    return rows.map((row) => ({
+      id: row.id,
+      blocker: row.blocker,
+      impact: row.impact,
+      affectedAreas: JSON.parse(row.affectedAreas),
+      when: row.when,
+      resolvedAt: row.resolvedAt,
+      resolution: row.resolution,
+      tags: JSON.parse(row.tags)
+    }));
+  }
+  /**
+   * Get hot cache item
+   */
+  getHot(key) {
+    return this.hotCache.get(key);
+  }
+  /**
+   * Set hot cache item
+   */
+  setHot(key, value) {
+    this.hotCache.set(key, value);
+  }
+  /**
+   * Clear hot cache
+   */
+  clearHot() {
+    this.hotCache.clear();
+  }
+  /**
+   * Archive old data to cold storage
+   */
+  async archiveToCold(olderThanDays = 90) {
+    if (!this.warmDb) await this.initialize();
+    if (!this.warmDb) throw new Error("Database not initialized");
+    const cutoffDate = /* @__PURE__ */ new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - olderThanDays);
+    const cutoff = cutoffDate.toISOString();
+    const coldDir = join3(getTrieDirectory(this.workDir), "cold");
+    const archivePath = join3(coldDir, `archive-${Date.now()}.json`);
+    const decisions = this.warmDb.prepare("SELECT * FROM decisions WHERE timestamp < ? AND accessCount < 3").all(cutoff);
+    const facts = this.warmDb.prepare("SELECT * FROM facts WHERE timestamp < ? AND accessCount < 3").all(cutoff);
+    const blockers = this.warmDb.prepare("SELECT * FROM blockers WHERE timestamp < ? AND resolvedAt IS NOT NULL").all(cutoff);
+    const questions = this.warmDb.prepare("SELECT * FROM questions WHERE timestamp < ? AND answeredAt IS NOT NULL").all(cutoff);
+    await writeFile2(archivePath, JSON.stringify({ decisions, facts, blockers, questions }, null, 2));
+    this.warmDb.prepare("DELETE FROM decisions WHERE timestamp < ? AND accessCount < 3").run(cutoff);
+    this.warmDb.prepare("DELETE FROM facts WHERE timestamp < ? AND accessCount < 3").run(cutoff);
+    this.warmDb.prepare("DELETE FROM blockers WHERE timestamp < ? AND resolvedAt IS NOT NULL").run(cutoff);
+    this.warmDb.prepare("DELETE FROM questions WHERE timestamp < ? AND answeredAt IS NOT NULL").run(cutoff);
+  }
+  /**
+   * Close database connection
+   */
+  close() {
+    if (this.warmDb) {
+      this.warmDb.close();
+      this.warmDb = null;
+    }
+  }
+};
+var storageInstances = /* @__PURE__ */ new Map();
+function getStorage(workDir) {
+  if (!storageInstances.has(workDir)) {
+    storageInstances.set(workDir, new TieredStorage(workDir));
+  }
+  return storageInstances.get(workDir);
+}
+
+// src/guardian/gotcha-predictor.ts
+import fs from "fs";
+import path from "path";
+var GotchaPredictor = class {
+  projectPath;
+  graph;
+  constructor(projectPath, graph) {
+    this.projectPath = projectPath;
+    this.graph = graph;
+  }
+  async predictGotchas(changedFiles) {
+    const gotchas = [];
+    const tickets = (await this.graph.listNodes()).filter((n) => n.type === "linear-ticket");
+    for (const file of changedFiles) {
+      const fileGotchas = await this.predictForFile(file, tickets);
+      gotchas.push(...fileGotchas);
+    }
+    return gotchas;
+  }
+  async predictForFile(filePath, tickets) {
+    const gotchas = [];
+    const fullPath = path.resolve(this.projectPath, filePath);
+    if (!fs.existsSync(fullPath)) return [];
+    const content = fs.readFileSync(fullPath, "utf-8");
+    const vulnerabilities = await scanForVulnerabilities(content, filePath);
+    const vibeIssues = await scanForVibeCodeIssues(content, filePath);
+    const signatures = [
+      ...vulnerabilities.map((v) => v.category),
+      ...vibeIssues.map((v) => v.category)
+    ];
+    const storage = getStorage(this.projectPath);
+    await storage.initialize();
+    const tags = this.extractTagsFromFile(filePath, signatures);
+    const relevantDecisions = await storage.queryDecisions({
+      tags,
+      limit: 10
+    });
+    const activeBlockers = await storage.queryBlockers({
+      tags,
+      limit: 5
+    });
+    for (const decision of relevantDecisions) {
+      if (decision.files.some((f) => f.includes(filePath) || filePath.includes(f))) {
+        gotchas.push({
+          id: `gotcha-decision-${decision.id}`,
+          message: `Decision: ${decision.decision}`,
+          confidence: 0.85,
+          riskLevel: "medium",
+          precedentId: decision.id,
+          recommendation: decision.reasoning || "Review this decision before making changes",
+          evidence: {
+            pastIncidents: [],
+            matchingPatterns: decision.tags,
+            relatedTickets: []
+          }
+        });
+      }
+    }
+    for (const blocker of activeBlockers) {
+      gotchas.push({
+        id: `gotcha-blocker-${blocker.id}`,
+        message: `\u26A0\uFE0F Active Blocker: ${blocker.blocker}`,
+        confidence: 0.95,
+        riskLevel: blocker.impact === "critical" ? "critical" : blocker.impact === "high" ? "high" : "medium",
+        recommendation: `This area is currently blocked. Consider resolving this before making changes.`,
+        evidence: {
+          pastIncidents: [],
+          matchingPatterns: blocker.tags,
+          relatedTickets: []
+        }
+      });
+    }
+    for (const ticket of tickets) {
+      const ticketData = ticket.data;
+      const intentMatch = this.correlateIntentWithSignatures(ticketData, signatures);
+      if (intentMatch) {
+        gotchas.push(intentMatch);
+      }
+      const historicalPrecedents = await this.findHistoricalPrecedents(filePath, ticketData);
+      if (historicalPrecedents) {
+        gotchas.push(historicalPrecedents);
+      }
+    }
+    return gotchas;
+  }
+  /**
+   * Extract tags from file path and signatures for storage queries
+   */
+  extractTagsFromFile(filePath, signatures) {
+    const tags = /* @__PURE__ */ new Set();
+    const normalized = filePath.toLowerCase();
+    if (normalized.includes("/auth/")) tags.add("auth");
+    if (normalized.includes("/payment/")) tags.add("payments");
+    if (normalized.includes("/api/")) tags.add("api");
+    if (normalized.includes("/frontend/") || normalized.includes("/ui/")) tags.add("ui");
+    if (normalized.includes("/backend/")) tags.add("backend");
+    if (normalized.includes("/database/") || normalized.includes("/models/")) tags.add("database");
+    signatures.forEach((sig) => tags.add(sig.toLowerCase()));
+    return Array.from(tags);
+  }
+  correlateIntentWithSignatures(ticket, signatures) {
+    const relevantSignatures = signatures.filter(
+      (sig) => ticket.intentVibe.some((vibe) => this.vibeToSignatureMap(vibe).includes(sig))
+    );
+    if (relevantSignatures.length > 0) {
+      return {
+        id: `gotcha-intent-${ticket.ticketId}-${Date.now()}`,
+        message: `[${ticket.ticketId}] Working on "${ticket.title}" (${ticket.intentVibe.join(", ")}) in a file with ${relevantSignatures.join(", ")} signatures.`,
+        confidence: 0.8,
+        riskLevel: "high",
+        recommendation: `Be careful with ${relevantSignatures[0]} patterns as they correlate with the intent of your ticket.`,
+        evidence: {
+          pastIncidents: [],
+          matchingPatterns: relevantSignatures,
+          relatedTickets: [ticket.ticketId]
+        }
+      };
+    }
+    return null;
+  }
+  async findHistoricalPrecedents(filePath, ticket) {
+    const similarIssues = await searchIssues(ticket.description, {
+      workDir: this.projectPath,
+      limit: 3
+    });
+    const relevantIssues = similarIssues.filter((r) => r.issue.file === filePath || r.issue.file.includes(path.basename(filePath)));
+    const [firstMatch] = relevantIssues;
+    if (firstMatch) {
+      const issue = firstMatch.issue;
+      return {
+        id: `gotcha-precedent-${ticket.ticketId}-${Date.now()}`,
+        message: `A similar task in the past caused an issue: "${issue.issue}"`,
+        confidence: 0.9,
+        riskLevel: "critical",
+        precedentId: issue.id,
+        recommendation: `Last time we worked on something similar here, we had to fix: "${issue.fix}". Check this first.`,
+        evidence: {
+          pastIncidents: [issue.id],
+          matchingPatterns: [],
+          relatedTickets: [ticket.ticketId]
+        }
+      };
+    }
+    return null;
+  }
+  vibeToSignatureMap(vibe) {
+    const map = {
+      "performance": ["giant-file", "performance", "react-antipattern"],
+      "security": ["injection", "secrets", "auth", "xss", "crypto"],
+      "auth": ["auth", "secrets", "config"],
+      "bug": ["no-error-handling", "async", "error-handling"],
+      "feature": ["mixing-concerns", "hardcoded"],
+      "refactor": ["code-smell", "giant-file", "mixing-concerns"]
+    };
+    return map[vibe] || [];
+  }
+  async synthesizeGotchaExplanation(gotcha) {
+    const client = tryGetClient();
+    if (!client) return gotcha.message;
+    const prompt = `
+      You are a JIT Defect Predictor. You found a potential "gotcha" for a developer.
+      
+      Ticket context: ${gotcha.evidence.relatedTickets.join(", ")}
+      Signatures detected: ${gotcha.evidence.matchingPatterns.join(", ")}
+      Past incidents: ${gotcha.evidence.pastIncidents.join(", ")}
+      
+      Raw message: ${gotcha.message}
+      Recommendation: ${gotcha.recommendation}
+      
+      Explain this gotcha in a concise, human-friendly way (max 2 sentences). 
+      Make it sound like a senior dev giving a helpful nudge.
+    `;
+    try {
+      const response = await client.messages.create({
+        model: "claude-3-5-sonnet-20240620",
+        max_tokens: 100,
+        messages: [{ role: "user", content: prompt }]
+      });
+      const text = response.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+      return text.trim() || gotcha.message;
+    } catch {
+      return gotcha.message;
+    }
+  }
+};
+
+// src/context/graph.ts
+import crypto from "crypto";
+import path3 from "path";
+
+// src/context/store.ts
+import Database2 from "better-sqlite3";
+import fs2 from "fs";
+import path2 from "path";
+var ContextStore = class {
+  db;
+  dbFilePath;
+  constructor(projectPath, dbFilePath) {
+    this.dbFilePath = dbFilePath ?? path2.join(getTrieDirectory(projectPath), "context.db");
+    this.ensureDirectory();
+    this.db = new Database2(this.dbFilePath);
+    this.configure();
+    this.prepareSchema();
+  }
+  get databasePath() {
+    return this.dbFilePath;
+  }
+  addNode(node) {
+    const stmt = this.db.prepare(
+      `INSERT INTO nodes (id, type, data, created_at, updated_at)
+       VALUES (@id, @type, @data, @created_at, @updated_at)`
+    );
+    stmt.run({
+      id: node.id,
+      type: node.type,
+      data: JSON.stringify(node.data),
+      created_at: node.created_at,
+      updated_at: node.updated_at
+    });
+    return node;
+  }
+  upsertNode(node) {
+    const stmt = this.db.prepare(
+      `INSERT INTO nodes (id, type, data, created_at, updated_at)
+       VALUES (@id, @type, @data, @created_at, @updated_at)
+       ON CONFLICT(id) DO UPDATE SET
+         type=excluded.type,
+         data=excluded.data,
+         updated_at=excluded.updated_at`
+    );
+    stmt.run({
+      id: node.id,
+      type: node.type,
+      data: JSON.stringify(node.data),
+      created_at: node.created_at,
+      updated_at: node.updated_at
+    });
+    return node;
+  }
+  getNode(id) {
+    const row = this.db.prepare("SELECT * FROM nodes WHERE id = ?").get(id);
+    return row ? this.mapNodeRow(row) : null;
+  }
+  getNodeByType(type, id) {
+    const row = this.db.prepare("SELECT * FROM nodes WHERE id = ? AND type = ?").get(id, type);
+    return row ? this.mapNodeRow(row) : null;
+  }
+  updateNode(id, updates, updatedAt) {
+    const existing = this.getNode(id);
+    if (!existing) {
+      return null;
+    }
+    const merged = {
+      ...existing,
+      data: { ...existing.data, ...updates },
+      updated_at: updatedAt
+    };
+    this.db.prepare(
+      `UPDATE nodes SET data = @data, updated_at = @updated_at
+         WHERE id = @id`
+    ).run({
+      id,
+      data: JSON.stringify(merged.data),
+      updated_at: merged.updated_at
+    });
+    return merged;
+  }
+  deleteNode(id) {
+    const deleteEdges = this.db.prepare("DELETE FROM edges WHERE from_id = ? OR to_id = ?");
+    const deleteNodeStmt = this.db.prepare("DELETE FROM nodes WHERE id = ?");
+    const transaction = this.db.transaction((nodeId) => {
+      deleteEdges.run(nodeId, nodeId);
+      deleteNodeStmt.run(nodeId);
+    });
+    transaction(id);
+  }
+  listNodes() {
+    const rows = this.db.prepare("SELECT * FROM nodes").all();
+    return rows.map((row) => this.mapNodeRow(row));
+  }
+  findNodesByType(type) {
+    const rows = this.db.prepare("SELECT * FROM nodes WHERE type = ?").all(type);
+    return rows.map((row) => this.mapNodeRow(row));
+  }
+  addEdge(edge) {
+    const stmt = this.db.prepare(
+      `INSERT INTO edges (id, from_id, to_id, type, weight, metadata, created_at)
+       VALUES (@id, @from_id, @to_id, @type, @weight, @metadata, @created_at)`
+    );
+    stmt.run({
+      id: edge.id,
+      from_id: edge.from_id,
+      to_id: edge.to_id,
+      type: edge.type,
+      weight: edge.weight,
+      metadata: JSON.stringify(edge.metadata ?? {}),
+      created_at: edge.created_at
+    });
+    return edge;
+  }
+  upsertEdge(edge) {
+    const stmt = this.db.prepare(
+      `INSERT INTO edges (id, from_id, to_id, type, weight, metadata, created_at)
+       VALUES (@id, @from_id, @to_id, @type, @weight, @metadata, @created_at)
+       ON CONFLICT(id) DO UPDATE SET
+         from_id=excluded.from_id,
+         to_id=excluded.to_id,
+         type=excluded.type,
+         weight=excluded.weight,
+         metadata=excluded.metadata`
+    );
+    stmt.run({
+      id: edge.id,
+      from_id: edge.from_id,
+      to_id: edge.to_id,
+      type: edge.type,
+      weight: edge.weight,
+      metadata: JSON.stringify(edge.metadata ?? {}),
+      created_at: edge.created_at
+    });
+    return edge;
+  }
+  getEdge(id) {
+    const row = this.db.prepare("SELECT * FROM edges WHERE id = ?").get(id);
+    return row ? this.mapEdgeRow(row) : null;
+  }
+  getEdges(nodeId, direction = "both") {
+    let rows;
+    if (direction === "in") {
+      rows = this.db.prepare("SELECT * FROM edges WHERE to_id = ?").all(nodeId);
+    } else if (direction === "out") {
+      rows = this.db.prepare("SELECT * FROM edges WHERE from_id = ?").all(nodeId);
+    } else {
+      rows = this.db.prepare("SELECT * FROM edges WHERE from_id = ? OR to_id = ?").all(nodeId, nodeId);
+    }
+    return rows.map((row) => this.mapEdgeRow(row));
+  }
+  listEdges() {
+    const rows = this.db.prepare("SELECT * FROM edges").all();
+    return rows.map((row) => this.mapEdgeRow(row));
+  }
+  deleteEdge(id) {
+    this.db.prepare("DELETE FROM edges WHERE id = ?").run(id);
+  }
+  close() {
+    this.db.close();
+  }
+  ensureDirectory() {
+    fs2.mkdirSync(path2.dirname(this.dbFilePath), { recursive: true });
+  }
+  configure() {
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("busy_timeout = 5000");
+    this.db.pragma("synchronous = NORMAL");
+  }
+  prepareSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS nodes (
+        id TEXT PRIMARY KEY,
+        type TEXT NOT NULL,
+        data TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS edges (
+        id TEXT PRIMARY KEY,
+        from_id TEXT NOT NULL,
+        to_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        weight REAL NOT NULL DEFAULT 1,
+        metadata TEXT DEFAULT '{}',
+        created_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_nodes_type ON nodes(type);
+      CREATE INDEX IF NOT EXISTS idx_edges_from ON edges(from_id);
+      CREATE INDEX IF NOT EXISTS idx_edges_to ON edges(to_id);
+      CREATE INDEX IF NOT EXISTS idx_edges_type ON edges(type);
+    `);
+  }
+  mapNodeRow(row) {
+    return {
+      id: row.id,
+      type: row.type,
+      data: JSON.parse(row.data),
+      created_at: row.created_at,
+      updated_at: row.updated_at
+    };
+  }
+  mapEdgeRow(row) {
+    return {
+      id: row.id,
+      from_id: row.from_id,
+      to_id: row.to_id,
+      type: row.type,
+      weight: row.weight,
+      created_at: row.created_at,
+      metadata: row.metadata ? JSON.parse(row.metadata) : {}
+    };
+  }
+};
+
+// src/context/graph.ts
+var ContextGraph = class {
+  store;
+  projectPath;
+  constructor(projectPath, dbPath, store) {
+    this.projectPath = projectPath;
+    this.store = store ?? new ContextStore(projectPath, dbPath);
+  }
+  get projectRoot() {
+    return this.projectPath;
+  }
+  async addNode(type, data) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = this.generateNodeId(type, data);
+    const node = {
+      id,
+      type,
+      data,
+      created_at: now,
+      updated_at: now
+    };
+    this.store.addNode(node);
+    return node;
+  }
+  async getNode(type, id) {
+    return this.store.getNodeByType(type, id);
+  }
+  async updateNode(type, id, updates) {
+    const updated = this.store.updateNode(id, updates, (/* @__PURE__ */ new Date()).toISOString());
+    if (updated && updated.type !== type) {
+      throw new Error(`Type mismatch for node ${id}: expected ${type} but found ${updated.type}`);
+    }
+  }
+  async deleteNode(_type, id) {
+    this.store.deleteNode(id);
+  }
+  async addEdge(fromId, toId, type, metadata = {}, weight = 1) {
+    const edge = {
+      id: crypto.randomUUID(),
+      from_id: fromId,
+      to_id: toId,
+      type,
+      weight,
+      metadata,
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.store.addEdge(edge);
+    return edge;
+  }
+  async getEdges(nodeId, direction = "both") {
+    return this.store.getEdges(nodeId, direction);
+  }
+  async getIncidentsForFile(filePath) {
+    const fileNode = this.findFileNode(filePath);
+    if (!fileNode) return [];
+    const incidents = /* @__PURE__ */ new Map();
+    const affectEdges = this.store.getEdges(fileNode.id, "in").filter((edge) => edge.type === "affects");
+    for (const edge of affectEdges) {
+      const changeId = edge.from_id;
+      const leadEdges = this.store.getEdges(changeId, "out").filter((e) => e.type === "leadTo");
+      const causedByEdges = this.store.getEdges(changeId, "in").filter((e) => e.type === "causedBy");
+      for (const le of leadEdges) {
+        const incident = this.store.getNodeByType("incident", le.to_id);
+        if (incident) incidents.set(incident.id, incident);
+      }
+      for (const ce of causedByEdges) {
+        const incident = this.store.getNodeByType("incident", ce.from_id);
+        if (incident) incidents.set(incident.id, incident);
+      }
+    }
+    return Array.from(incidents.values());
+  }
+  async getPatternsForFile(filePath) {
+    const normalized = this.normalizePath(filePath);
+    const nodes = this.store.findNodesByType("pattern");
+    return nodes.filter(
+      (node) => node.data.appliesTo.some((pattern) => normalized.includes(pattern) || filePath.includes(pattern))
+    );
+  }
+  async getRecentChanges(limit) {
+    const nodes = this.store.findNodesByType("change");
+    return nodes.sort((a, b) => new Date(b.data.timestamp).getTime() - new Date(a.data.timestamp).getTime()).slice(0, limit);
+  }
+  async calculateFileRisk(filePath) {
+    const fileNode = this.findFileNode(filePath);
+    if (!fileNode) return "low";
+    const incidentScore = Math.min(fileNode.data.incidentCount * 2, 6);
+    const changeScore = Math.min(fileNode.data.changeCount, 4);
+    const baseScore = this.riskLevelToScore(fileNode.data.riskLevel);
+    const total = baseScore + incidentScore + changeScore;
+    if (total >= 10) return "critical";
+    if (total >= 7) return "high";
+    if (total >= 4) return "medium";
+    return "low";
+  }
+  async listNodes() {
+    return this.store.listNodes();
+  }
+  async listEdges() {
+    return this.store.listEdges();
+  }
+  async deleteEdge(id) {
+    this.store.deleteEdge(id);
+  }
+  async getSnapshot() {
+    return {
+      nodes: this.store.listNodes(),
+      edges: this.store.listEdges(),
+      exported_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async applySnapshot(snapshot) {
+    for (const node of snapshot.nodes) {
+      const existing = this.store.getNode(node.id);
+      if (!existing || this.isNewer(node.updated_at, existing.updated_at)) {
+        this.store.upsertNode(node);
+      }
+    }
+    for (const edge of snapshot.edges) {
+      const existing = this.store.getEdge(edge.id);
+      if (!existing) {
+        this.store.upsertEdge(edge);
+      }
+    }
+  }
+  generateNodeId(type, data) {
+    if (type === "file") {
+      const fileData = data;
+      return this.normalizePath(fileData.path);
+    }
+    if (type === "change") {
+      const changeData = data;
+      if (changeData.commitHash) {
+        return changeData.commitHash;
+      }
+    }
+    if (type === "linear-ticket") {
+      const ticketData = data;
+      return `linear:${ticketData.ticketId}`;
+    }
+    return crypto.randomUUID();
+  }
+  findFileNode(filePath) {
+    const normalized = this.normalizePath(filePath);
+    const nodes = this.store.findNodesByType("file");
+    return nodes.find(
+      (node) => node.id === normalized || this.normalizePath(node.data.path) === normalized || node.data.path === filePath
+    ) ?? null;
+  }
+  normalizePath(filePath) {
+    return path3.resolve(this.projectPath, filePath);
+  }
+  riskLevelToScore(level) {
+    switch (level) {
+      case "critical":
+        return 6;
+      case "high":
+        return 4;
+      case "medium":
+        return 2;
+      default:
+        return 0;
+    }
+  }
+  isNewer(incoming, existing) {
+    return new Date(incoming).getTime() >= new Date(existing).getTime();
+  }
+};
+
+export {
+  recordToGlobalMemory,
+  findCrossProjectPatterns,
+  listTrackedProjects,
+  getGlobalMemoryStats,
+  updateGlobalMemoryMd,
+  searchGlobalPatterns,
+  isAIAvailable,
+  runAIAnalysis,
+  getStorage,
+  GotchaPredictor,
+  ContextGraph
+};
+//# sourceMappingURL=chunk-NIASHOAB.js.map