@triedotdev/mcp 1.0.113 → 1.0.114

package/dist/{chunk-6QR6QZIX.js → chunk-D3EXBJE2.js}

@@ -1,20 +1,26 @@
 import {
-  scanForVibeCodeIssues
-} from "./chunk-IXO4G4D3.js";
+  tryGetClient
+} from "./chunk-SWSK7ANT.js";
 import {
-  BackupManager,
-  GlobalPatternsIndexSchema,
-  atomicWriteJSON,
-  safeParseAndValidate,
   searchIssues
-} from "./chunk-6JPPYG7F.js";
+} from "./chunk-55DOQNHJ.js";
 import {
-  getTrieDirectory,
-  getWorkingDirectory
-} from "./chunk-R4AAPFXC.js";
+  BackupManager,
+  GlobalPatternsIndexSchema,
+  safeParseAndValidate
+} from "./chunk-KRH642MT.js";
 import {
   scanForVulnerabilities
 } from "./chunk-F4NJ4CBP.js";
+import {
+  scanForVibeCodeIssues
+} from "./chunk-IXO4G4D3.js";
+import {
+  atomicWriteJSON
+} from "./chunk-43X6JBEM.js";
+import {
+  getTrieDirectory
+} from "./chunk-R4AAPFXC.js";
 
 // src/memory/global-memory.ts
 import { mkdir, writeFile, readFile, readdir } from "fs/promises";
@@ -266,256 +272,9 @@ function sanitizeName(name) {
   return name.replace(/[^a-zA-Z0-9-_]/g, "-").toLowerCase();
 }
 
-// src/ai/client.ts
-import Anthropic from "@anthropic-ai/sdk";
-import { readFileSync, writeFileSync, mkdirSync, existsSync as existsSync2 } from "fs";
-import { execSync } from "child_process";
-import { join as join2 } from "path";
-var clientInstance = null;
-var apiKeyChecked = false;
-var apiKeyAvailable = false;
-function isAIAvailable() {
-  if (!apiKeyChecked) {
-    checkAPIKey();
-  }
-  return apiKeyAvailable;
-}
-function getKeyFromKeychain() {
-  if (process.platform !== "darwin") return null;
-  try {
-    const result = execSync(
-      'security find-generic-password -a "trie" -s "anthropic-api-key" -w 2>/dev/null',
-      { encoding: "utf-8" }
-    ).trim();
-    return result.length > 10 ? result : null;
-  } catch {
-    return null;
-  }
-}
-function saveKeyToKeychain(key) {
-  if (process.platform !== "darwin") return false;
-  try {
-    try {
-      execSync('security delete-generic-password -a "trie" -s "anthropic-api-key" 2>/dev/null');
-    } catch {
-    }
-    execSync(`security add-generic-password -a "trie" -s "anthropic-api-key" -w "${key.replace(/"/g, '\\"')}"`);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function setAPIKey(key) {
-  process.env.ANTHROPIC_API_KEY = key;
-  clientInstance = null;
-  apiKeyChecked = true;
-  apiKeyAvailable = true;
-  if (saveKeyToKeychain(key)) {
-    return { saved: true, method: "keychain" };
-  }
-  try {
-    const workDir = getWorkingDirectory(void 0, true);
-    const trieDir = getTrieDirectory(workDir);
-    const configPath = join2(trieDir, "config.json");
-    let config = {};
-    if (existsSync2(configPath)) {
-      config = JSON.parse(readFileSync(configPath, "utf-8"));
-    }
-    if (!config.apiKeys || typeof config.apiKeys !== "object") config.apiKeys = {};
-    config.apiKeys.anthropic = key;
-    mkdirSync(trieDir, { recursive: true });
-    writeFileSync(configPath, JSON.stringify(config, null, 2));
-  } catch {
-  }
-  return { saved: true, method: "config" };
-}
-function checkAPIKey() {
-  apiKeyChecked = true;
-  const envApiKey = process.env.ANTHROPIC_API_KEY;
-  if (envApiKey && envApiKey.length > 10) {
-    apiKeyAvailable = true;
-    return;
-  }
-  const keychainKey = getKeyFromKeychain();
-  if (keychainKey) {
-    process.env.ANTHROPIC_API_KEY = keychainKey;
-    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}`
-    };
-  }
-}
-async function runAIWithTools(request) {
-  const client = tryGetClient();
-  if (!client) {
-    return { success: false, content: "", error: "AI not available - ANTHROPIC_API_KEY not set" };
-  }
-  const maxRounds = request.maxToolRounds ?? 5;
-  const messages = [...request.messages];
-  const allToolCalls = [];
-  try {
-    for (let round = 0; round < maxRounds; round++) {
-      const response = await client.messages.create({
-        model: "claude-sonnet-4-20250514",
-        max_tokens: request.maxTokens || 4096,
-        temperature: 0.3,
-        system: request.systemPrompt,
-        messages,
-        tools: request.tools
-      });
-      const toolUseBlocks = response.content.filter(
-        (b) => b.type === "tool_use"
-      );
-      const textBlocks = response.content.filter(
-        (b) => b.type === "text"
-      );
-      if (toolUseBlocks.length === 0) {
-        const result2 = {
-          success: true,
-          content: textBlocks.map((b) => b.text).join("\n")
-        };
-        if (allToolCalls.length > 0) result2.toolCalls = allToolCalls;
-        return result2;
-      }
-      messages.push({ role: "assistant", content: response.content });
-      const toolResults = [];
-      for (const block of toolUseBlocks) {
-        const input = block.input ?? {};
-        allToolCalls.push({ name: block.name, input });
-        let resultText;
-        let isError = false;
-        try {
-          resultText = await request.executeTool(block.name, input);
-        } catch (err) {
-          resultText = `Tool error: ${err instanceof Error ? err.message : String(err)}`;
-          isError = true;
-        }
-        toolResults.push({
-          type: "tool_result",
-          tool_use_id: block.id,
-          content: resultText,
-          is_error: isError
-        });
-      }
-      messages.push({ role: "user", content: toolResults });
-      if (response.stop_reason === "end_turn") {
-        const text = textBlocks.map((b) => b.text).join("\n");
-        const result2 = { success: true, content: text || "Done." };
-        if (allToolCalls.length > 0) result2.toolCalls = allToolCalls;
-        return result2;
-      }
-    }
-    const result = { success: true, content: "Reached maximum tool rounds." };
-    if (allToolCalls.length > 0) result.toolCalls = allToolCalls;
-    return result;
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    return { success: false, content: "", error: `AI tool-use failed: ${errorMessage}` };
-  }
-}
-
 // src/storage/tiered-storage.ts
 import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join2 } from "path";
 import { createHash as createHash2 } from "crypto";
 import Database from "better-sqlite3";
 var TieredStorage = class {
@@ -530,10 +289,10 @@ var TieredStorage = class {
    */
   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");
+    await mkdir2(join2(trieDir, "hot"), { recursive: true });
+    await mkdir2(join2(trieDir, "warm"), { recursive: true });
+    await mkdir2(join2(trieDir, "cold"), { recursive: true });
+    const dbPath = join2(trieDir, "warm", "decisions.db");
     this.warmDb = new Database(dbPath);
     this.warmDb.exec(`
       CREATE TABLE IF NOT EXISTS decisions (
@@ -815,8 +574,8 @@ var TieredStorage = class {
     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 coldDir = join2(getTrieDirectory(this.workDir), "cold");
+    const archivePath = join2(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);
@@ -1031,392 +790,6 @@ var GotchaPredictor = class {
   }
 };
 
-// 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,
@@ -1424,14 +797,8 @@ export {
   getGlobalMemoryStats,
   updateGlobalMemoryMd,
   searchGlobalPatterns,
-  isAIAvailable,
-  getKeyFromKeychain,
-  setAPIKey,
-  runAIAnalysis,
-  runAIWithTools,
   TieredStorage,
   getStorage,
-  GotchaPredictor,
-  ContextGraph
+  GotchaPredictor
 };
-//# sourceMappingURL=chunk-6QR6QZIX.js.map
+//# sourceMappingURL=chunk-D3EXBJE2.js.map