@syndash/research-vault-mcp 1.1.2 → 1.1.3

package/src/vault_write.ts

@@ -1,16 +1,33 @@
-import { readFileSync, writeFileSync, existsSync, statSync, mkdirSync, unlinkSync, realpathSync, readdirSync } from 'fs'
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, realpathSync } from 'fs'
 import { join, dirname, basename, resolve as pathResolve } from 'path'
 import { homedir } from 'os'
 import { IngestJobStore, computeChecksum } from './vault_jobs.js'
 import { parseArxivId, fetchArxivMetadata } from './ingest/arxiv.js'
 import { fetchHtml } from './ingest/html.js'
-import type { VaultEntry, RawIngestInput, NoteSaveInput, VaultGetInput, VaultDeleteInput, DecayScore } from './types.js'
+import { scanKnowledge } from './vault.js'
+import type { RawIngestInput, NoteSaveInput, VaultDeleteInput, DecayScore } from './types.js'
 
-const VAULT_ROOT = process.env.VAULT_ROOT ?? `${homedir()}/Documents/Evensong/research-vault`
-const KNOWLEDGE_DIR = join(VAULT_ROOT, 'knowledge')
-const RAW_DIR = join(VAULT_ROOT, 'raw')
-const DECAY_PATH = join(VAULT_ROOT, '.meta', 'decay-scores.json')
-const CHECKSUMS_PATH = join(VAULT_ROOT, '.meta', 'checksums.json')
+const DEFAULT_VAULT_ROOT = `${homedir()}/Documents/Evensong/research-vault`
+
+function getVaultRoot(): string {
+  return process.env.VAULT_ROOT ?? DEFAULT_VAULT_ROOT
+}
+
+function getKnowledgeDir(): string {
+  return join(getVaultRoot(), 'knowledge')
+}
+
+function getRawDir(): string {
+  return join(getVaultRoot(), 'raw')
+}
+
+function getDecayPath(): string {
+  return join(getVaultRoot(), '.meta', 'decay-scores.json')
+}
+
+function getChecksumsPath(): string {
+  return join(getVaultRoot(), '.meta', 'checksums.json')
+}
 
 function ensureDir(p: string) {
   if (!existsSync(p)) mkdirSync(p, { recursive: true })
@@ -18,16 +35,23 @@ function ensureDir(p: string) {
 
 function safePath(root: string, target: string): string {
   const joined = join(root, target)
+  let resolvedRoot: string
+  try {
+    resolvedRoot = realpathSync(root)
+  } catch {
+    resolvedRoot = pathResolve(root)
+  }
+
   let resolved: string
   try {
     resolved = realpathSync(joined)
   } catch {
     // Path doesn't exist yet (new file). Use resolve to normalize .. components
     // and verify the final path stays within root.
-    resolved = pathResolve(joined)
+    resolved = pathResolve(resolvedRoot, target)
   }
   // Normalize both to remove trailing slashes for prefix comparison
-  const rootNorm = root.replace(/\\/g, '/').replace(/\/$/, '')
+  const rootNorm = resolvedRoot.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')
@@ -42,39 +66,52 @@ export function normalizeId(raw: string): string {
     .replace(/\.md$/, '')
 }
 
-function loadDecayScores(): Record<string, DecayScore> {
-  try { return JSON.parse(readFileSync(DECAY_PATH, 'utf-8')) } catch { return {} }
+function loadDecayScores(): DecayScore[] {
+  try {
+    const data = JSON.parse(readFileSync(getDecayPath(), 'utf-8'))
+    if (Array.isArray(data)) return data
+    if (data && typeof data === 'object') return Object.values(data) as DecayScore[]
+    return []
+  } catch {
+    return []
+  }
 }
 
-function saveDecayScores(scores: Record<string, DecayScore>) {
-  ensureDir(dirname(DECAY_PATH))
-  writeFileSync(DECAY_PATH, JSON.stringify(scores, null, 2), 'utf-8')
+function saveDecayScores(scores: DecayScore[]) {
+  const decayPath = getDecayPath()
+  ensureDir(dirname(decayPath))
+  writeFileSync(decayPath, JSON.stringify(scores, null, 2), 'utf-8')
 }
 
 function loadChecksums(): Record<string, { sha256: string; writtenAt: string }> {
-  try { return JSON.parse(readFileSync(CHECKSUMS_PATH, 'utf-8')) } catch { return {} }
+  try { return JSON.parse(readFileSync(getChecksumsPath(), 'utf-8')) } catch { return {} }
 }
 
 function saveChecksums(store: Record<string, { sha256: string; writtenAt: string }>) {
-  ensureDir(dirname(CHECKSUMS_PATH))
-  writeFileSync(CHECKSUMS_PATH, JSON.stringify(store, null, 2), 'utf-8')
+  const checksumsPath = getChecksumsPath()
+  ensureDir(dirname(checksumsPath))
+  writeFileSync(checksumsPath, JSON.stringify(store, null, 2), 'utf-8')
 }
 
 // ─── ingest helpers ──────────────────────────────────────────────────────────────
 
-const jobStore = new IngestJobStore(VAULT_ROOT)
+function getJobStore(): IngestJobStore {
+  return new IngestJobStore(getVaultRoot())
+}
 
 async function ingestArxiv(value: string, category: string) {
   const id = parseArxivId(value)
   if (!id) throw new Error(`Invalid ArXiv ID: ${value}`)
 
+  const jobStore = getJobStore()
+  const metaPath = safePath(getRawDir(), join(category, `arxiv-${id}.meta.json`))
+
   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 = join(RAW_DIR, category, `arxiv-${id}.meta.json`)
   ensureDir(dirname(metaPath))
   writeFileSync(metaPath, JSON.stringify(metadata, null, 2), 'utf-8')
 
@@ -88,6 +125,10 @@ async function ingestArxiv(value: string, category: string) {
 }
 
 async function ingestUrl(value: string, category: string) {
+  const rawDir = getRawDir()
+  safePath(rawDir, category)
+
+  const jobStore = getJobStore()
   const job = await jobStore.createJob({ source: 'url', value, category })
   await jobStore.updateJob(job.jobId, { status: 'fetching' })
 
@@ -95,7 +136,7 @@ async function ingestUrl(value: string, category: string) {
     try {
       const text = await fetchHtml(value)
       const safeName = value.replace(/[^a-z0-9]/gi, '_').slice(0, 64)
-      const rawPath = join(RAW_DIR, category, `${Date.now()}--${safeName}.html`)
+      const rawPath = safePath(rawDir, join(category, `${Date.now()}--${safeName}.md`))
       ensureDir(dirname(rawPath))
       writeFileSync(rawPath, text, 'utf-8')
 
@@ -115,10 +156,14 @@ async function ingestUrl(value: string, category: string) {
 
 async function ingestFile(value: string, category: string) {
   if (!existsSync(value)) throw new Error(`File not found: ${value}`)
+
+  const rawDir = getRawDir()
+  safePath(rawDir, category)
+
+  const jobStore = getJobStore()
   const job = await jobStore.createJob({ source: 'file', value, category })
-  const destDir = join(RAW_DIR, category)
-  ensureDir(destDir)
-  const destPath = join(destDir, `${Date.now()}--${basename(value)}`)
+  const destPath = safePath(rawDir, join(category, `${Date.now()}--${basename(value)}`))
+  ensureDir(dirname(destPath))
   const content = readFileSync(value)
   writeFileSync(destPath, content)
 
@@ -136,18 +181,19 @@ async function ingestFile(value: string, category: string) {
 async function saveNote(input: NoteSaveInput) {
   const safeTitle = input.title.replace(/[^a-z0-9]/gi, '-').slice(0, 32)
   const id = `${Date.now()}--${safeTitle}`
-  const filePath = safePath(KNOWLEDGE_DIR, join(input.category, `${id}.md`))
+  const filePath = safePath(getKnowledgeDir(), join(input.category, `${id}.md`))
   ensureDir(dirname(filePath))
   const content = `# ${input.title}\n\n${input.content}\n`
   writeFileSync(filePath, content, 'utf-8')
 
   const scores = loadDecayScores()
-  scores[id] = {
+  const filtered = scores.filter(s => normalizeId(s.itemId) !== normalizeId(id))
+  filtered.push({
     itemId: id, score: 0.5, lastAccess: new Date().toISOString(),
     accessCount: 0, summaryLevel: input.summaryLevel ?? 'none',
     nextReviewAt: new Date().toISOString(), difficulty: 0.5
-  }
-  saveDecayScores(scores)
+  })
+  saveDecayScores(filtered)
 
   const hash = await computeChecksum(filePath)
   const checksums = loadChecksums()
@@ -157,42 +203,13 @@ async function saveNote(input: NoteSaveInput) {
   return { id, path: filePath, writtenAt: new Date().toISOString() }
 }
 
-// ─── vault_get ────────────────────────────────────────────────────────────────
-
-function getEntry(input: VaultGetInput) {
-  let filePath: string
-
-  if (input.path) {
-    filePath = safePath(VAULT_ROOT, input.path)
-  } else if (input.id) {
-    const entry = scanKnowledge().find(e => normalizeId(e.id) === normalizeId(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 = readFileSync(filePath, 'utf-8')
-  const s = statSync(filePath)
-  const relPath = filePath.replace(VAULT_ROOT + '/', '')
-
-  return {
-    id: normalizeId(basename(filePath)),
-    title: (content.match(/^#\s+(.+)/m)?.[1]) ?? normalizeId(basename(filePath)),
-    category: relPath.includes('/') ? relPath.split('/').slice(0, -1).join('/') : '',
-    content,
-    modified: s.mtime.toISOString(),
-    size: s.size
-  }
-}
-
 // ─── vault_delete ─────────────────────────────────────────────────────────────
 
 function deleteEntry(input: VaultDeleteInput) {
   let filePath: string
 
   if (input.path) {
-    filePath = safePath(VAULT_ROOT, input.path)
+    filePath = safePath(getVaultRoot(), input.path)
   } else if (input.id) {
     const entry = scanKnowledge().find(e => normalizeId(e.id) === normalizeId(input.id!))
     if (!entry) throw new Error(`Entry not found: ${input.id}`)
@@ -205,8 +222,8 @@ function deleteEntry(input: VaultDeleteInput) {
 
   const id = normalizeId(basename(filePath))
   const scores = loadDecayScores()
-  delete scores[id]
-  saveDecayScores(scores)
+  const filtered = scores.filter(s => normalizeId(s.itemId) !== normalizeId(id))
+  saveDecayScores(filtered)
 
   const checksums = loadChecksums()
   delete checksums[filePath]
@@ -215,37 +232,6 @@ function deleteEntry(input: VaultDeleteInput) {
   return { deleted: true, path: filePath }
 }
 
-// ─── scanKnowledge ───────────────────────────────────────────────────────────
-
-function scanKnowledge(): VaultEntry[] {
-  const entries: VaultEntry[] = []
-  if (!existsSync(KNOWLEDGE_DIR)) return entries
-  try {
-    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
-      try {
-        const files = readdirSync(catPath).filter((f: string) => f.endsWith('.md'))
-        for (const file of files) {
-          const fp = join(catPath, file)
-          const s = statSync(fp)
-          entries.push({
-            id: normalizeId(file),
-            title: normalizeId(file),
-            category: cat,
-            path: fp,
-            modified: s.mtime.toISOString(),
-            size: s.size
-          })
-        }
-      } catch {}
-    }
-  } catch {}
-  return entries
-}
-
 // ─── Tool Definitions ──────────────────────────────────────────────────────────
 
 export const vaultWriteTools = [
@@ -257,7 +243,7 @@ export const vaultWriteTools = [
       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"' },
+        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' }
       },
@@ -265,7 +251,7 @@ export const vaultWriteTools = [
     },
     call: async (args: RawIngestInput) => {
       try {
-        const category = args.category ?? 'inbox'
+        const category = args.category ?? '_inbox'
         let job
         if (args.source === 'arxiv') {
           job = await ingestArxiv(args.value, category)
@@ -305,26 +291,6 @@ export const vaultWriteTools = [
     }
   },
 
-  {
-    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: VaultGetInput) => {
-      try {
-        const result = getEntry(args)
-        return { content: [{ type: 'text', text: JSON.stringify(result) }] }
-      } catch (e: unknown) {
-        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).',