@syndash/research-vault-mcp 1.1.0 → 1.1.2

package/dist/server.js

@@ -0,0 +1,1154 @@
+// @bun
+var __require = import.meta.require;
+
+// src/vault.ts
+import { readFileSync, readdirSync, existsSync, statSync } from "fs";
+import { join, basename } from "path";
+import { homedir } from "os";
+var VAULT_ROOT = process.env.VAULT_ROOT ?? `${homedir()}/Documents/Evensong/research-vault`;
+var KNOWLEDGE_DIR = join(VAULT_ROOT, "knowledge");
+var RAW_DIR = join(VAULT_ROOT, "raw");
+var DECAY_PATH = join(VAULT_ROOT, ".meta", "decay-scores.json");
+var TAXONOMY_PATH = join(VAULT_ROOT, "knowledge", "_taxonomy.md");
+function normalizeId(raw) {
+  return raw.replace(/^\d{8}--?\d{4}-/, "").replace(/^(\d{10,})--?/, "").replace(/\.md$/, "");
+}
+function loadDecayScores() {
+  try {
+    return JSON.parse(readFileSync(DECAY_PATH, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function loadTaxonomy() {
+  try {
+    return readFileSync(TAXONOMY_PATH, "utf-8");
+  } catch {
+    return "";
+  }
+}
+function loadFileMeta(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const lines = content.split(`
+`);
+    let title = "";
+    for (const line of lines.slice(0, 30)) {
+      const m = line.match(/^#\s+(.+)/);
+      if (m) {
+        title = m[1];
+        break;
+      }
+    }
+    const s = statSync(filePath);
+    return {
+      title: title || normalizeId(basename(filePath)),
+      modified: s.mtime.toISOString(),
+      size: s.size
+    };
+  } catch {
+    return { title: normalizeId(basename(filePath)), modified: "", size: 0 };
+  }
+}
+function scanKnowledge() {
+  const entries = [];
+  if (!existsSync(KNOWLEDGE_DIR))
+    return entries;
+  const categories = readdirSync(KNOWLEDGE_DIR);
+  for (const cat of categories) {
+    if (cat.startsWith("_"))
+      continue;
+    const catPath = join(KNOWLEDGE_DIR, cat);
+    if (!existsSync(catPath) || !statSync(catPath).isDirectory())
+      continue;
+    const subEntries = readdirSync(catPath);
+    for (const sub of subEntries) {
+      const subPath = join(catPath, sub);
+      const subStat = statSync(subPath);
+      if (subStat.isDirectory()) {
+        const files = readdirSync(subPath).filter((f) => f.endsWith(".md"));
+        for (const file of files) {
+          const fp = join(subPath, file);
+          const meta = loadFileMeta(fp);
+          entries.push({
+            id: normalizeId(file),
+            title: meta.title,
+            category: `${cat}/${sub}`,
+            path: fp,
+            modified: meta.modified,
+            size: meta.size
+          });
+        }
+      } else if (sub.endsWith(".md")) {
+        const meta = loadFileMeta(subPath);
+        entries.push({
+          id: normalizeId(sub),
+          title: meta.title,
+          category: cat,
+          path: subPath,
+          modified: meta.modified,
+          size: meta.size
+        });
+      }
+    }
+  }
+  return entries;
+}
+function scanRaw() {
+  const pending = [];
+  if (!existsSync(RAW_DIR))
+    return pending;
+  try {
+    const entries = readdirSync(RAW_DIR);
+    for (const entry of entries) {
+      if (entry === "_inbox") {
+        const inbox = join(RAW_DIR, entry);
+        if (existsSync(inbox)) {
+          pending.push(...readdirSync(inbox).filter((f) => /\.(md|pdf|txt)$/.test(f)));
+        }
+      } else if (/^\d{4}-\d{2}$/.test(entry)) {
+        const monthDir = join(RAW_DIR, entry);
+        if (existsSync(monthDir)) {
+          pending.push(...readdirSync(monthDir).filter((f) => /\.(md|pdf|txt)$/.test(f)).map((f) => `${entry}/${f}`));
+        }
+      }
+    }
+  } catch {}
+  return pending;
+}
+var vaultTools = [
+  {
+    name: "vault_search",
+    description: "Search the Research Vault knowledge base. Returns analyzed papers with retention scores.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query (matches title, category)" },
+        category: { type: "string", description: 'Filter by category (e.g., "ai-agents/benchmarking")' },
+        limit: { type: "number", description: "Max results (default 10)" }
+      }
+    },
+    call: async ({ query, category, limit = 10 }) => {
+      let items = scanKnowledge();
+      const scores = loadDecayScores();
+      const scoreMap = new Map(scores.map((s) => [normalizeId(s.itemId), s]));
+      if (category) {
+        items = items.filter((item) => item.category === category || item.category.startsWith(category + "/"));
+      }
+      if (query) {
+        const q = query.toLowerCase();
+        items = items.filter((item) => item.title.toLowerCase().includes(q) || item.id.toLowerCase().includes(q) || item.category.toLowerCase().includes(q));
+      }
+      const results = items.slice(0, limit).map((item) => {
+        const sid = item.id.replace(/--/g, "-");
+        const score = scoreMap.get(item.id) || scoreMap.get(sid);
+        return {
+          id: item.id,
+          title: item.title,
+          category: item.category,
+          score: score?.score ?? null,
+          summaryLevel: score?.summaryLevel ?? null,
+          nextReview: score?.nextReviewAt ?? null,
+          accessCount: score?.accessCount ?? 0,
+          modified: item.modified
+        };
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ query, category, results, total: results.length }, null, 2)
+        }]
+      };
+    }
+  },
+  {
+    name: "vault_status",
+    description: "Get Research Vault health \u2014 item counts by decay level, top/bottom retention.",
+    inputSchema: { type: "object", properties: {} },
+    call: async () => {
+      const scores = loadDecayScores();
+      const entries = scanKnowledge();
+      const deep = scores.filter((s) => s.summaryLevel === "deep");
+      const shallow = scores.filter((s) => s.summaryLevel === "shallow");
+      const none = scores.filter((s) => s.summaryLevel === "none");
+      const sorted = [...scores].sort((a, b) => b.score - a.score);
+      const top5 = sorted.slice(0, 5).map((s) => {
+        const sid = s.itemId.replace(/--/g, "-");
+        const entry = entries.find((e) => normalizeId(e.id) === normalizeId(s.itemId) || normalizeId(e.id) === normalizeId(sid));
+        return { itemId: s.itemId, score: s.score, accesses: s.accessCount, title: entry?.title || s.itemId };
+      });
+      const bottom5 = sorted.slice(-5).reverse().map((s) => {
+        const sid = s.itemId.replace(/--/g, "-");
+        const entry = entries.find((e) => normalizeId(e.id) === normalizeId(s.itemId) || normalizeId(e.id) === normalizeId(sid));
+        return { itemId: s.itemId, score: s.score, lastAccess: s.lastAccess.slice(0, 10), title: entry?.title || s.itemId };
+      });
+      const pending = scanRaw();
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            total: entries.length,
+            analyzed: scores.length,
+            deep: deep.length,
+            shallow: shallow.length,
+            dormant: none.length,
+            pending_raw: pending.length,
+            top5,
+            bottom5
+          }, null, 2)
+        }]
+      };
+    }
+  },
+  {
+    name: "vault_batch_analyze",
+    description: "Check batch analyze status and pending papers in the raw queue.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        count: { type: "number", description: "Preview N papers (default 5)" }
+      }
+    },
+    call: async ({ count = 5 } = {}) => {
+      const pending = scanRaw();
+      const entries = scanKnowledge();
+      const analyzedIds = new Set(entries.map((e) => normalizeId(e.id)));
+      const unanalyzed = pending.filter((p) => {
+        const id = normalizeId(p);
+        return !analyzedIds.has(id);
+      });
+      if (unanalyzed.length === 0) {
+        return { content: [{ type: "text", text: JSON.stringify({ message: "Queue empty \u2014 all papers analyzed", analyzed: entries.length }) }] };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            message: `${unanalyzed.length} papers pending analysis`,
+            pending: unanalyzed.length,
+            preview: unanalyzed.slice(0, count),
+            hint: "cd ~/Desktop/research-vault && bun run scripts/batch-analyze.ts --count N"
+          }, null, 2)
+        }]
+      };
+    }
+  },
+  {
+    name: "vault_taxonomy",
+    description: "Get the Research Vault taxonomy \u2014 all categories and counts.",
+    inputSchema: { type: "object", properties: {} },
+    call: async () => {
+      const taxonomy = loadTaxonomy();
+      const entries = scanKnowledge();
+      const catCounts = {};
+      for (const e of entries)
+        catCounts[e.category] = (catCounts[e.category] || 0) + 1;
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ taxonomy, categories: catCounts }, null, 2)
+        }]
+      };
+    }
+  }
+];
+
+// src/vault_write.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync3, statSync as statSync2, mkdirSync as mkdirSync2, unlinkSync, realpathSync, readdirSync as readdirSync2 } from "fs";
+import { join as join3, dirname, basename as basename2, resolve as pathResolve } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/vault_jobs.ts
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2, mkdirSync } from "fs";
+import { join as join2 } from "path";
+import { createHash, randomUUID } from "crypto";
+var JOBS_FILE = "ingest-jobs.json";
+var CHECKSUMS_FILE = "checksums.json";
+
+class IngestJobStore {
+  vaultRoot;
+  metaDir;
+  constructor(vaultRoot) {
+    this.vaultRoot = vaultRoot;
+    this.metaDir = join2(this.vaultRoot, ".meta");
+    if (!existsSync2(this.metaDir))
+      mkdirSync(this.metaDir, { recursive: true });
+  }
+  jobsPath() {
+    return join2(this.metaDir, JOBS_FILE);
+  }
+  checksumsPath() {
+    return join2(this.metaDir, CHECKSUMS_FILE);
+  }
+  loadJobs() {
+    try {
+      return JSON.parse(readFileSync2(this.jobsPath(), "utf-8"));
+    } catch {
+      return {};
+    }
+  }
+  saveJobs(jobs) {
+    writeFileSync(this.jobsPath(), JSON.stringify(jobs, null, 2), "utf-8");
+  }
+  loadChecksums() {
+    try {
+      return JSON.parse(readFileSync2(this.checksumsPath(), "utf-8"));
+    } catch {
+      return {};
+    }
+  }
+  saveChecksums(store) {
+    writeFileSync(this.checksumsPath(), JSON.stringify(store, null, 2), "utf-8");
+  }
+  async createJob(input) {
+    const jobs = this.loadJobs();
+    const now = new Date().toISOString();
+    const job = {
+      jobId: randomUUID(),
+      source: input.source,
+      value: input.value,
+      category: input.category ?? "inbox",
+      status: "queued",
+      rawPath: null,
+      metadata: null,
+      createdAt: now,
+      updatedAt: now
+    };
+    jobs[job.jobId] = job;
+    this.saveJobs(jobs);
+    return job;
+  }
+  async getJob(jobId) {
+    return this.loadJobs()[jobId] ?? null;
+  }
+  async updateJob(jobId, updates) {
+    const jobs = this.loadJobs();
+    const job = jobs[jobId];
+    if (!job)
+      return null;
+    jobs[jobId] = { ...job, ...updates, updatedAt: new Date().toISOString() };
+    this.saveJobs(jobs);
+    return jobs[jobId];
+  }
+  async getAllJobs() {
+    return Object.values(this.loadJobs());
+  }
+}
+async function computeChecksum(filePath) {
+  const file = Bun.file(filePath);
+  const buffer = await file.arrayBuffer();
+  const hash = createHash("sha256");
+  hash.update(Buffer.from(buffer));
+  return hash.digest("hex");
+}
+
+// src/ingest/arxiv.ts
+var ARXIV_API = "https://export.arxiv.org/api/query";
+function parseArxivId(value) {
+  if (/^\d{4}\.\d{4,}(v\d+)?$/.test(value.trim())) {
+    return value.trim();
+  }
+  const m = value.match(/(?:arxiv\.org\/abs\/|abs\/?)(\d{4}\.\d{4,}(?:v\d+)?)/i);
+  return m ? m[1] : null;
+}
+async function fetchArxivMetadata(id) {
+  const url = `${ARXIV_API}?id_list=${id}`;
+  const res = await fetch(url);
+  if (!res.ok)
+    throw new Error(`ArXiv API error: ${res.status}`);
+  const xml = await res.text();
+  return parseArxivXml(xml);
+}
+function parseArxivXml(xml) {
+  const titleMatch = xml.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  const title = titleMatch ? titleMatch[1].replace(/\s+/g, " ").trim() : null;
+  const summaryMatch = xml.match(/<summary[^>]*>([\s\S]*?)<\/summary>/i);
+  const abstract = summaryMatch ? summaryMatch[1].replace(/\s+/g, " ").trim() : null;
+  const authors = [];
+  const authorRe = /<author>[\s\S]*?<name>([\s\S]*?)<\/name>[\s\S]*?<\/author>/gi;
+  let m;
+  while ((m = authorRe.exec(xml)) !== null) {
+    authors.push(m[1].replace(/\s+/g, " ").trim());
+  }
+  const categories = [];
+  const catRe = /<category[^>]*term="([^"]+)"/gi;
+  while ((m = catRe.exec(xml)) !== null)
+    categories.push(m[1]);
+  return {
+    title,
+    authors: authors.length ? authors : null,
+    abstract,
+    arxivId: null,
+    categories: categories.length ? categories : null
+  };
+}
+
+// src/ingest/html.ts
+function validateUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+  const scheme = parsed.protocol.toLowerCase();
+  if (scheme !== "http:" && scheme !== "https:") {
+    throw new Error(`URL scheme not allowed: ${scheme}. Only http/https permitted.`);
+  }
+  const hostname = parsed.hostname.toLowerCase();
+  if (hostname === "169.254.169.254" || hostname === "metadata.google.internal") {
+    throw new Error(`Cloud metadata endpoint blocked: ${hostname}`);
+  }
+  if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]") {
+    throw new Error(`Localhost not permitted: ${hostname}`);
+  }
+  const ip = hostname;
+  if (/^(10\.\d+|172\.(1[6-9]|2\d|3[01])\.\d+\.\d+|192\.168\.\d+)$/.test(ip)) {
+    throw new Error(`Private IP not permitted: ${ip}`);
+  }
+  if (hostname.startsWith("169.254.")) {
+    throw new Error(`Link-local IP blocked: ${hostname}`);
+  }
+}
+async function fetchHtml(url) {
+  validateUrl(url);
+  const res = await fetch(url, {
+    headers: {
+      "User-Agent": "Mozilla/5.0 research-vault-mcp/1.1.0",
+      Accept: "text/html"
+    }
+  });
+  if (!res.ok)
+    throw new Error(`HTTP ${res.status} fetching ${url}`);
+  const html = await res.text();
+  let text = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<nav[\s\S]*?<\/nav>/gi, "").replace(/<footer[\s\S]*?<\/footer>/gi, "").replace(/<header[\s\S]*?<\/header>/gi, "").replace(/<aside[\s\S]*?<\/aside>/gi, "").replace(/<!--[\s\S]*?-->/g, "");
+  text = text.replace(/<\/(p|div|br|h[1-6]|li|tr)>/gi, `
+`);
+  text = text.replace(/<[^>]+>/g, "");
+  text = text.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+  text = text.replace(/\n{3,}/g, `
+
+`).trim();
+  return text;
+}
+
+// src/vault_write.ts
+var VAULT_ROOT2 = process.env.VAULT_ROOT ?? `${homedir2()}/Documents/Evensong/research-vault`;
+var KNOWLEDGE_DIR2 = join3(VAULT_ROOT2, "knowledge");
+var RAW_DIR2 = join3(VAULT_ROOT2, "raw");
+var DECAY_PATH2 = join3(VAULT_ROOT2, ".meta", "decay-scores.json");
+var CHECKSUMS_PATH = join3(VAULT_ROOT2, ".meta", "checksums.json");
+function ensureDir(p) {
+  if (!existsSync3(p))
+    mkdirSync2(p, { recursive: true });
+}
+function safePath(root, target) {
+  const joined = join3(root, target);
+  let resolved;
+  try {
+    resolved = realpathSync(joined);
+  } catch {
+    resolved = pathResolve(joined);
+  }
+  const rootNorm = root.replace(/\\/g, "/").replace(/\/$/, "");
+  const resolvedNorm = resolved.replace(/\\/g, "/").replace(/\/$/, "");
+  if (!resolvedNorm.startsWith(rootNorm + "/") && resolvedNorm !== rootNorm) {
+    throw new Error("Path traversal detected: target outside vault root");
+  }
+  return resolved;
+}
+function normalizeId2(raw) {
+  return raw.replace(/^\d{8}--?\d{4}-/, "").replace(/^(\d{10,})--?/, "").replace(/\.md$/, "");
+}
+function loadDecayScores2() {
+  try {
+    return JSON.parse(readFileSync3(DECAY_PATH2, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveDecayScores(scores) {
+  ensureDir(dirname(DECAY_PATH2));
+  writeFileSync2(DECAY_PATH2, JSON.stringify(scores, null, 2), "utf-8");
+}
+function loadChecksums() {
+  try {
+    return JSON.parse(readFileSync3(CHECKSUMS_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveChecksums(store) {
+  ensureDir(dirname(CHECKSUMS_PATH));
+  writeFileSync2(CHECKSUMS_PATH, JSON.stringify(store, null, 2), "utf-8");
+}
+var jobStore = new IngestJobStore(VAULT_ROOT2);
+async function ingestArxiv(value, category) {
+  const id = parseArxivId(value);
+  if (!id)
+    throw new Error(`Invalid ArXiv ID: ${value}`);
+  const job = await jobStore.createJob({ source: "arxiv", value: id, category });
+  await jobStore.updateJob(job.jobId, { status: "fetching" });
+  const metadata = await fetchArxivMetadata(id);
+  metadata.arxivId = id;
+  const metaPath = join3(RAW_DIR2, category, `arxiv-${id}.meta.json`);
+  ensureDir(dirname(metaPath));
+  writeFileSync2(metaPath, JSON.stringify(metadata, null, 2), "utf-8");
+  const hash = await computeChecksum(metaPath);
+  const checksums = loadChecksums();
+  checksums[metaPath] = { sha256: hash, writtenAt: new Date().toISOString() };
+  saveChecksums(checksums);
+  await jobStore.updateJob(job.jobId, { status: "queued", rawPath: metaPath, metadata });
+  return job;
+}
+async function ingestUrl(value, category) {
+  const job = await jobStore.createJob({ source: "url", value, category });
+  await jobStore.updateJob(job.jobId, { status: "fetching" });
+  (async () => {
+    try {
+      const text = await fetchHtml(value);
+      const safeName = value.replace(/[^a-z0-9]/gi, "_").slice(0, 64);
+      const rawPath = join3(RAW_DIR2, category, `${Date.now()}--${safeName}.html`);
+      ensureDir(dirname(rawPath));
+      writeFileSync2(rawPath, text, "utf-8");
+      const hash = await computeChecksum(rawPath);
+      const checksums = loadChecksums();
+      checksums[rawPath] = { sha256: hash, writtenAt: new Date().toISOString() };
+      saveChecksums(checksums);
+      await jobStore.updateJob(job.jobId, { status: "queued", rawPath });
+    } catch (e) {
+      await jobStore.updateJob(job.jobId, { status: "failed", error: e instanceof Error ? e.message : String(e) });
+    }
+  })();
+  return job;
+}
+async function ingestFile(value, category) {
+  if (!existsSync3(value))
+    throw new Error(`File not found: ${value}`);
+  const job = await jobStore.createJob({ source: "file", value, category });
+  const destDir = join3(RAW_DIR2, category);
+  ensureDir(destDir);
+  const destPath = join3(destDir, `${Date.now()}--${basename2(value)}`);
+  const content = readFileSync3(value);
+  writeFileSync2(destPath, content);
+  const hash = await computeChecksum(destPath);
+  const checksums = loadChecksums();
+  checksums[destPath] = { sha256: hash, writtenAt: new Date().toISOString() };
+  saveChecksums(checksums);
+  await jobStore.updateJob(job.jobId, { status: "queued", rawPath: destPath });
+  return job;
+}
+async function saveNote(input) {
+  const safeTitle = input.title.replace(/[^a-z0-9]/gi, "-").slice(0, 32);
+  const id = `${Date.now()}--${safeTitle}`;
+  const filePath = safePath(KNOWLEDGE_DIR2, join3(input.category, `${id}.md`));
+  ensureDir(dirname(filePath));
+  const content = `# ${input.title}
+
+${input.content}
+`;
+  writeFileSync2(filePath, content, "utf-8");
+  const scores = loadDecayScores2();
+  scores[id] = {
+    itemId: id,
+    score: 0.5,
+    lastAccess: new Date().toISOString(),
+    accessCount: 0,
+    summaryLevel: input.summaryLevel ?? "none",
+    nextReviewAt: new Date().toISOString(),
+    difficulty: 0.5
+  };
+  saveDecayScores(scores);
+  const hash = await computeChecksum(filePath);
+  const checksums = loadChecksums();
+  checksums[filePath] = { sha256: hash, writtenAt: new Date().toISOString() };
+  saveChecksums(checksums);
+  return { id, path: filePath, writtenAt: new Date().toISOString() };
+}
+function getEntry(input) {
+  let filePath;
+  if (input.path) {
+    filePath = safePath(VAULT_ROOT2, input.path);
+  } else if (input.id) {
+    const entry = scanKnowledge2().find((e) => normalizeId2(e.id) === normalizeId2(input.id));
+    if (!entry)
+      throw new Error(`Entry not found: ${input.id}`);
+    filePath = entry.path;
+  } else {
+    throw new Error("id or path required");
+  }
+  const content = readFileSync3(filePath, "utf-8");
+  const s = statSync2(filePath);
+  const relPath = filePath.replace(VAULT_ROOT2 + "/", "");
+  return {
+    id: normalizeId2(basename2(filePath)),
+    title: content.match(/^#\s+(.+)/m)?.[1] ?? normalizeId2(basename2(filePath)),
+    category: relPath.includes("/") ? relPath.split("/").slice(0, -1).join("/") : "",
+    content,
+    modified: s.mtime.toISOString(),
+    size: s.size
+  };
+}
+function deleteEntry(input) {
+  let filePath;
+  if (input.path) {
+    filePath = safePath(VAULT_ROOT2, input.path);
+  } else if (input.id) {
+    const entry = scanKnowledge2().find((e) => normalizeId2(e.id) === normalizeId2(input.id));
+    if (!entry)
+      throw new Error(`Entry not found: ${input.id}`);
+    filePath = entry.path;
+  } else {
+    throw new Error("id or path required");
+  }
+  unlinkSync(filePath);
+  const id = normalizeId2(basename2(filePath));
+  const scores = loadDecayScores2();
+  delete scores[id];
+  saveDecayScores(scores);
+  const checksums = loadChecksums();
+  delete checksums[filePath];
+  saveChecksums(checksums);
+  return { deleted: true, path: filePath };
+}
+function scanKnowledge2() {
+  const entries = [];
+  if (!existsSync3(KNOWLEDGE_DIR2))
+    return entries;
+  try {
+    const categories = readdirSync2(KNOWLEDGE_DIR2);
+    for (const cat of categories) {
+      if (cat.startsWith("_"))
+        continue;
+      const catPath = join3(KNOWLEDGE_DIR2, cat);
+      if (!existsSync3(catPath) || !statSync2(catPath).isDirectory())
+        continue;
+      try {
+        const files = readdirSync2(catPath).filter((f) => f.endsWith(".md"));
+        for (const file of files) {
+          const fp = join3(catPath, file);
+          const s = statSync2(fp);
+          entries.push({
+            id: normalizeId2(file),
+            title: normalizeId2(file),
+            category: cat,
+            path: fp,
+            modified: s.mtime.toISOString(),
+            size: s.size
+          });
+        }
+      } catch {}
+    }
+  } catch {}
+  return entries;
+}
+var vaultWriteTools = [
+  {
+    name: "vault_raw_ingest",
+    description: "Fire-and-forget ingest of URL/file/ArXiv to raw vault layer. Returns jobId for async progress polling.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        source: { type: "string", enum: ["url", "file", "arxiv"] },
+        value: { type: "string", description: "URL / absolute file path / ArXiv ID or URL" },
+        category: { type: "string", description: 'raw/ subdirectory, default "inbox"' },
+        priority: { type: "string", enum: ["high", "low"], default: "low" },
+        arxivMetadata: { type: "boolean", description: "ArXiv: fetch metadata before storing, default true" }
+      },
+      required: ["source", "value"]
+    },
+    call: async (args) => {
+      try {
+        const category = args.category ?? "inbox";
+        let job;
+        if (args.source === "arxiv") {
+          job = await ingestArxiv(args.value, category);
+        } else if (args.source === "url") {
+          job = await ingestUrl(args.value, category);
+        } else {
+          job = await ingestFile(args.value, category);
+        }
+        return { content: [{ type: "text", text: JSON.stringify(job) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: e instanceof Error ? e.message : String(e) }], isError: true };
+      }
+    }
+  },
+  {
+    name: "vault_note_save",
+    description: "Write a structured note to the knowledge layer.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string" },
+        content: { type: "string" },
+        category: { type: "string" },
+        tags: { type: "array", items: { type: "string" } },
+        summaryLevel: { type: "string", enum: ["deep", "shallow", "none"] }
+      },
+      required: ["title", "content", "category"]
+    },
+    call: async (args) => {
+      try {
+        const result = await saveNote(args);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: e instanceof Error ? e.message : String(e) }], isError: true };
+      }
+    }
+  },
+  {
+    name: "vault_get",
+    description: "Read full content of a vault entry by id or path.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string" },
+        path: { type: "string" }
+      }
+    },
+    call: async (args) => {
+      try {
+        const result = getEntry(args);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: e instanceof Error ? e.message : String(e) }], isError: true };
+      }
+    }
+  },
+  {
+    name: "vault_delete",
+    description: "Delete a vault entry (raw or knowledge).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string" },
+        path: { type: "string" }
+      }
+    },
+    call: async (args) => {
+      try {
+        const result = deleteEntry(args);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: e instanceof Error ? e.message : String(e) }], isError: true };
+      }
+    }
+  }
+];
+
+// src/amplify.ts
+var AMPLIFY_BASE = "https://prod-api.vanderbilt.ai";
+var config = null;
+function configureAmplify(apiKey) {
+  config = { apiKey };
+}
+function getHeaders() {
+  if (!config?.apiKey)
+    throw new Error("Amplify API key not configured. Call configureAmplify() first.");
+  return {
+    Authorization: `Bearer ${config.apiKey}`,
+    "Content-Type": "application/json"
+  };
+}
+var amplifyTools = [
+  {
+    name: "amplify_list_models",
+    description: "List available models on Vanderbilt Amplify. Returns model IDs, context windows, providers, and pricing tiers.",
+    inputSchema: { type: "object", properties: {} },
+    call: async () => {
+      try {
+        const res = await fetch(`${AMPLIFY_BASE}/available_models`, {
+          headers: getHeaders()
+        });
+        if (!res.ok)
+          throw new Error(`HTTP ${res.status}`);
+        const data = await res.json();
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(data, null, 2)
+          }]
+        };
+      } catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+      }
+    }
+  },
+  {
+    name: "amplify_chat",
+    description: "Send a streaming chat message to Amplify. Returns Claude/GPT/Mistral responses via SSE.",
+    inputSchema: {
+      type: "object",
+      required: ["message"],
+      properties: {
+        message: { type: "string", description: "User message" },
+        modelId: { type: "string", description: "Model ID (from amplify_list_models)" },
+        systemPrompt: { type: "string", description: "Optional system prompt override" },
+        temperature: { type: "number", description: "Temperature (0-2, default 0.7)" },
+        maxTokens: { type: "number", description: "Max output tokens (default 4000)" },
+        stream: { type: "boolean", description: "If true, yield chunks via onProgress callback instead of waiting for complete response (default false)" }
+      }
+    },
+    call: async ({ message, modelId, systemPrompt, temperature = 0.7, maxTokens = 4000, stream = false }, onProgress) => {
+      try {
+        const body = {
+          data: {
+            model: modelId || "gpt-4o",
+            temperature,
+            max_tokens: maxTokens,
+            messages: [{ role: "user", content: message }]
+          }
+        };
+        if (systemPrompt) {
+          body.data.messages.unshift({ role: "system", content: systemPrompt });
+        }
+        const res = await fetch(`${AMPLIFY_BASE}/chat`, {
+          method: "POST",
+          headers: getHeaders(),
+          body: JSON.stringify(body)
+        });
+        if (!res.ok) {
+          const err = await res.text();
+          throw new Error(`HTTP ${res.status}: ${err}`);
+        }
+        const reader = res.body?.getReader();
+        if (!reader)
+          throw new Error("No response body");
+        let fullText = "";
+        const decoder = new TextDecoder;
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          const chunk = decoder.decode(value, { stream: true });
+          for (const line of chunk.split(`
+`)) {
+            if (line.startsWith("data: ")) {
+              try {
+                const parsed = JSON.parse(line.slice(6));
+                if (parsed.data?.content)
+                  fullText += parsed.data.content;
+                else if (parsed.data)
+                  fullText += typeof parsed.data === "string" ? parsed.data : JSON.stringify(parsed.data);
+              } catch {}
+            }
+          }
+        }
+        if (stream && onProgress) {
+          const res2 = await fetch(`${AMPLIFY_BASE}/chat`, {
+            method: "POST",
+            headers: getHeaders(),
+            body: JSON.stringify(body)
+          });
+          if (!res2.ok)
+            throw new Error(`HTTP ${res2.status}`);
+          const reader2 = res2.body?.getReader();
+          if (!reader2)
+            throw new Error("No response body");
+          const decoder2 = new TextDecoder;
+          let buffer2 = "";
+          while (true) {
+            const { done, value } = await reader2.read();
+            if (done)
+              break;
+            buffer2 += decoder2.decode(value, { stream: true });
+            for (const line of buffer2.split(`
+`)) {
+              if (line.startsWith("data: ")) {
+                try {
+                  const parsed = JSON.parse(line.slice(6));
+                  if (parsed.data?.content) {
+                    onProgress({ type: "chunk", text: parsed.data.content });
+                  }
+                } catch {}
+              }
+            }
+          }
+          return { content: [{ type: "text", text: "(streamed)" }] };
+        }
+        return {
+          content: [{ type: "text", text: fullText || "(no response)" }]
+        };
+      } catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+      }
+    }
+  },
+  {
+    name: "amplify_files_query",
+    description: "Query uploaded files on Amplify using semantic search. Returns relevant file chunks.",
+    inputSchema: {
+      type: "object",
+      required: ["query"],
+      properties: {
+        query: { type: "string", description: "Search query" },
+        limit: { type: "number", description: "Max results (default 5)" }
+      }
+    },
+    call: async ({ query, limit = 5 }) => {
+      try {
+        const res = await fetch(`${AMPLIFY_BASE}/files/query`, {
+          method: "POST",
+          headers: getHeaders(),
+          body: JSON.stringify({ query, limit })
+        });
+        if (!res.ok)
+          throw new Error(`HTTP ${res.status}`);
+        const data = await res.json();
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+      }
+    }
+  },
+  {
+    name: "amplify_files_list",
+    description: "List tags/categories of uploaded files on Amplify.",
+    inputSchema: { type: "object", properties: {} },
+    call: async () => {
+      try {
+        const res = await fetch(`${AMPLIFY_BASE}/files/tags/list`, {
+          headers: getHeaders()
+        });
+        if (!res.ok)
+          throw new Error(`HTTP ${res.status}`);
+        const data = await res.json();
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+      }
+    }
+  },
+  {
+    name: "amplify_assistants_list",
+    description: "List your Amplify assistants.",
+    inputSchema: { type: "object", properties: {} },
+    call: async () => {
+      try {
+        const res = await fetch(`${AMPLIFY_BASE}/assistant/list`, {
+          headers: getHeaders()
+        });
+        if (!res.ok)
+          throw new Error(`HTTP ${res.status}`);
+        const data = await res.json();
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      } catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }], isError: true };
+      }
+    }
+  }
+];
+
+// src/server.ts
+var HOST = "0.0.0.0";
+var TRANSPORT = process.env.MCP_TRANSPORT ?? "stdio";
+var PORT = parseInt(process.env.MCP_PORT ?? "8765");
+var allTools = [
+  ...vaultTools,
+  ...vaultWriteTools,
+  ...amplifyTools
+];
+var toolMap = new Map(allTools.map((t) => [t.name, t]));
+var sessions = new Map;
+function makeResponse(id, result, error) {
+  return { jsonrpc: "2.0", id, result, error };
+}
+function generateSessionId() {
+  return crypto.randomUUID();
+}
+async function handleRequest(req) {
+  const { method, id, params } = req;
+  if (method === "notifications/initialized" || method === "notifications/cancelled") {
+    return null;
+  }
+  if (method === "initialize") {
+    return makeResponse(id, {
+      protocolVersion: "2024-11-05",
+      capabilities: {
+        tools: { listChanged: false }
+      },
+      serverInfo: {
+        name: "research-vault-mcp",
+        version: "1.0.0"
+      }
+    });
+  }
+  if (method === "tools/list") {
+    return makeResponse(id, {
+      tools: allTools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema
+      }))
+    });
+  }
+  if (method === "tools/call") {
+    const { name, arguments: args } = params;
+    console.error("[DEBUG] tools/call:", name, JSON.stringify(args));
+    const tool = toolMap.get(name);
+    if (!tool) {
+      return makeResponse(id, undefined, { code: -32602, message: `Unknown tool: ${name}` });
+    }
+    try {
+      const result = await tool.call(args || {});
+      return makeResponse(id, { content: result.content, isError: result.isError });
+    } catch (e) {
+      return makeResponse(id, undefined, { code: -32603, message: `Tool error: ${e.message}` });
+    }
+  }
+  if (method === "ping") {
+    return makeResponse(id, {});
+  }
+  return makeResponse(id, undefined, { code: -32601, message: `Method not found: ${method}` });
+}
+async function handleStdioTransport() {
+  const rl = await import("readline");
+  const rli = rl.createInterface({ input: process.stdin, crlfDelay: Infinity });
+  const writer = Bun.stdout.writer();
+  const send = (obj) => {
+    writer.write(JSON.stringify(obj) + `
+`);
+    writer.flush();
+  };
+  for await (const line of rli) {
+    if (!line.trim())
+      continue;
+    try {
+      const req = JSON.parse(line);
+      const result = await handleRequest(req);
+      if (result)
+        send(result);
+    } catch (e) {
+      send({ jsonrpc: "2.0", error: { code: -32700, message: `Parse error: ${e instanceof Error ? e.message : String(e)}` } });
+    }
+  }
+}
+var server;
+if (TRANSPORT !== "stdio") {
+  server = Bun.serve({
+    port: PORT,
+    hostname: HOST,
+    async fetch(req) {
+      const url = new URL(req.url);
+      if (url.pathname === "/sse" && req.method === "GET") {
+        const sessionId = generateSessionId();
+        const stream = new ReadableStream({
+          start(controller) {
+            const encoder = new TextEncoder;
+            const send = (data) => {
+              try {
+                controller.enqueue(encoder.encode(data));
+              } catch {}
+            };
+            send(`event: endpoint
+data: /messages?sessionId=${sessionId}
+
+`);
+            const heartbeat = setInterval(() => {
+              try {
+                controller.enqueue(encoder.encode(`: heartbeat
+
+`));
+              } catch {
+                clearInterval(heartbeat);
+                sessions.delete(sessionId);
+              }
+            }, 15000);
+            sessions.set(sessionId, { send, heartbeat });
+            console.error(`[SSE] Session ${sessionId} connected`);
+            req.signal.addEventListener("abort", () => {
+              clearInterval(heartbeat);
+              sessions.delete(sessionId);
+              console.error(`[SSE] Session ${sessionId} disconnected`);
+            });
+          }
+        });
+        return new Response(stream, {
+          status: 200,
+          headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+            "X-Accel-Buffering": "no"
+          }
+        });
+      }
+      if (url.pathname === "/messages" && req.method === "POST") {
+        const sessionId = url.searchParams.get("sessionId");
+        if (!sessionId || !sessions.has(sessionId)) {
+          return Response.json({ error: "Invalid or missing sessionId" }, { status: 400 });
+        }
+        const session = sessions.get(sessionId);
+        try {
+          const body = await req.json();
+          const result = await handleRequest(body);
+          if (result) {
+            session.send(`event: message
+data: ${JSON.stringify(result)}
+
+`);
+          }
+          return new Response(null, { status: 202 });
+        } catch (e) {
+          return Response.json({ jsonrpc: "2.0", error: { code: -32700, message: `Parse error: ${e.message}` } }, { status: 400 });
+        }
+      }
+      if (url.pathname === "/health" && req.method === "GET") {
+        return Response.json({
+          status: "ok",
+          tools: allTools.length,
+          vault_tools: vaultTools.length,
+          amplify_tools: amplifyTools.length,
+          sse_sessions: sessions.size,
+          uptime: process.uptime()
+        });
+      }
+      if (url.pathname === "/configure" && req.method === "POST") {
+        try {
+          const { apiKey } = await req.json();
+          if (!apiKey)
+            throw new Error("apiKey required");
+          configureAmplify(apiKey);
+          return Response.json({ status: "configured" });
+        } catch (e) {
+          return Response.json({ error: e.message }, { status: 400 });
+        }
+      }
+      return Response.json({ error: "Not found" }, { status: 404 });
+    }
+  });
+}
+if (TRANSPORT === "stdio") {
+  console.error("[MCP] Running in stdio mode (stdin/stdout JSON-RPC)");
+  await handleStdioTransport();
+  process.exit(0);
+} else {
+  console.log(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551   Research Vault MCP Server \u2014 MCP SSE Transport     \u2551
+\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563
+\u2551  SSE:       http://${HOST}:${PORT}/sse                \u2551
+\u2551  Messages:  http://${HOST}:${PORT}/messages          \u2551
+\u2551  Health:    http://${HOST}:${PORT}/health            \u2551
+\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563
+\u2551  Tools:     ${String(allTools.length).padEnd(3)} (${vaultTools.length} vault, ${amplifyTools.length} amplify)     \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`);
+}
+process.on("SIGINT", () => {
+  console.log(`
+Shutting down...`);
+  for (const [id, session] of sessions) {
+    clearInterval(session.heartbeat);
+  }
+  sessions.clear();
+  server?.stop();
+  process.exit(0);
+});