context-vault 3.1.5 → 3.1.7

package/scripts/prepack.js

@@ -1,33 +1,27 @@
 #!/usr/bin/env node
 
-import {
-  cpSync,
-  rmSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
-} from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { cpSync, rmSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const LOCAL_ROOT = join(__dirname, "..");
-const NODE_MODULES = join(LOCAL_ROOT, "node_modules");
-const CORE_SRC = join(LOCAL_ROOT, "..", "core");
-const CORE_DEST = join(NODE_MODULES, "@context-vault", "core");
+const LOCAL_ROOT = join(__dirname, '..');
+const NODE_MODULES = join(LOCAL_ROOT, 'node_modules');
+const CORE_SRC = join(LOCAL_ROOT, '..', 'core');
+const CORE_DEST = join(NODE_MODULES, '@context-vault', 'core');
 
 // Clean node_modules to prevent workspace deps from leaking into the tarball.
 // Only @context-vault/core should be bundled.
 rmSync(NODE_MODULES, { recursive: true, force: true });
 
 // Ensure target directory exists
-mkdirSync(join(NODE_MODULES, "@context-vault"), { recursive: true });
+mkdirSync(join(NODE_MODULES, '@context-vault'), { recursive: true });
 
 // Copy core package (dereference symlinks)
 cpSync(CORE_SRC, CORE_DEST, { recursive: true, dereference: true });
 
 // Remove nested node_modules from the copy
-rmSync(join(CORE_DEST, "node_modules"), { recursive: true, force: true });
+rmSync(join(CORE_DEST, 'node_modules'), { recursive: true, force: true });
 
 // Strip all dependencies from the bundled core's package.json.
 // Core's deps (sqlite-vec, MCP SDK) are hoisted to
@@ -35,9 +29,9 @@ rmSync(join(CORE_DEST, "node_modules"), { recursive: true, force: true });
 // dynamically imported and installed via postinstall.  Leaving them
 // in the bundled core causes duplicate resolution that breaks native
 // module install scripts in global npm contexts.
-const corePkgPath = join(CORE_DEST, "package.json");
-const corePkg = JSON.parse(readFileSync(corePkgPath, "utf8"));
+const corePkgPath = join(CORE_DEST, 'package.json');
+const corePkg = JSON.parse(readFileSync(corePkgPath, 'utf8'));
 delete corePkg.dependencies;
-writeFileSync(corePkgPath, JSON.stringify(corePkg, null, 2) + "\n");
+writeFileSync(corePkgPath, JSON.stringify(corePkg, null, 2) + '\n');
 
-console.log("[prepack] Bundled @context-vault/core into node_modules");
+console.log('[prepack] Bundled @context-vault/core into node_modules');

package/src/archive.js

@@ -0,0 +1,211 @@
+import { existsSync, mkdirSync, renameSync, readFileSync } from 'node:fs';
+import { join, dirname, relative } from 'node:path';
+import { categoryDirFor, categoryFor, defaultTierFor } from '@context-vault/core/categories';
+import { parseFrontmatter, parseEntryFromMarkdown } from '@context-vault/core/frontmatter';
+import { DEFAULT_LIFECYCLE } from '@context-vault/core/constants';
+import { walkDir } from '@context-vault/core/files';
+import { indexEntry } from '@context-vault/core/index';
+
+const VALID_TIERS = new Set(['ephemeral', 'working', 'durable']);
+const VALID_CATEGORIES = new Set(['knowledge', 'entity', 'event']);
+
+function resolveLifecycle(config) {
+  return config?.lifecycle ?? structuredClone(DEFAULT_LIFECYCLE);
+}
+
+function archiveDir(vaultDir) {
+  return join(vaultDir, '_archive');
+}
+
+export function findArchiveCandidates(ctx) {
+  const lifecycle = resolveLifecycle(ctx.config);
+  const now = new Date();
+  const candidates = [];
+  const seen = new Set();
+
+  for (const [key, rules] of Object.entries(lifecycle)) {
+    if (!rules?.archiveAfterDays) continue;
+    const cutoff = new Date(now.getTime() - rules.archiveAfterDays * 86400000).toISOString();
+
+    const isTier = VALID_TIERS.has(key);
+    const isCategory = VALID_CATEGORIES.has(key);
+    if (!isTier && !isCategory) continue;
+
+    const column = isTier ? 'tier' : 'category';
+    const rows = ctx.db
+      .prepare(
+        `SELECT id, kind, category, title, tier, file_path, created_at, updated_at
+         FROM vault
+         WHERE ${column} = ? AND COALESCE(updated_at, created_at) <= ?
+         ORDER BY COALESCE(updated_at, created_at) ASC`
+      )
+      .all(key, cutoff);
+
+    for (const row of rows) {
+      if (seen.has(row.id)) continue;
+      seen.add(row.id);
+      candidates.push({
+        ...row,
+        reason: `${column}=${key}, archiveAfterDays=${rules.archiveAfterDays}`,
+      });
+    }
+  }
+
+  return candidates;
+}
+
+function removeFromIndex(ctx, id) {
+  const rowidRow = ctx.stmts.getRowid.get(id);
+  if (rowidRow?.rowid) {
+    try {
+      ctx.deleteVec(Number(rowidRow.rowid));
+    } catch {}
+  }
+  ctx.stmts.deleteEntry.run(id);
+}
+
+export async function archiveEntries(ctx) {
+  const candidates = findArchiveCandidates(ctx);
+  if (candidates.length === 0) return { archived: candidates, count: 0 };
+
+  const vaultDir = ctx.config.vaultDir;
+  const archRoot = archiveDir(vaultDir);
+  let count = 0;
+
+  for (const entry of candidates) {
+    const filePath = entry.file_path;
+    if (!filePath) {
+      removeFromIndex(ctx, entry.id);
+      count++;
+      continue;
+    }
+
+    const rel = relative(vaultDir, filePath);
+    if (rel.startsWith('..') || rel.startsWith('_archive')) continue;
+
+    const destPath = join(archRoot, rel);
+    const destDir = dirname(destPath);
+
+    try {
+      mkdirSync(destDir, { recursive: true });
+      renameSync(filePath, destPath);
+    } catch (e) {
+      if (e.code === 'ENOENT' && !existsSync(filePath)) {
+        // File already gone — just remove from index
+      } else {
+        throw e;
+      }
+    }
+
+    removeFromIndex(ctx, entry.id);
+    count++;
+  }
+
+  return { archived: candidates, count };
+}
+
+export async function restoreEntry(ctx, entryId) {
+  const vaultDir = ctx.config.vaultDir;
+  const archRoot = archiveDir(vaultDir);
+
+  if (!existsSync(archRoot)) {
+    return { restored: false, reason: 'no _archive directory' };
+  }
+
+  const mdFiles = walkDir(archRoot);
+  let targetFile = null;
+
+  for (const { filePath } of mdFiles) {
+    try {
+      const raw = readFileSync(filePath, 'utf-8');
+      const { meta } = parseFrontmatter(raw);
+      if (meta.id === entryId) {
+        targetFile = filePath;
+        break;
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  if (!targetFile) {
+    return { restored: false, reason: `entry ${entryId} not found in _archive` };
+  }
+
+  const rel = relative(archRoot, targetFile);
+  const destPath = join(vaultDir, rel);
+  const destDir = dirname(destPath);
+
+  if (existsSync(destPath)) {
+    return { restored: false, reason: `destination already exists: ${destPath}` };
+  }
+
+  mkdirSync(destDir, { recursive: true });
+  renameSync(targetFile, destPath);
+
+  const raw = readFileSync(destPath, 'utf-8');
+  const { meta, body: rawBody } = parseFrontmatter(raw);
+
+  const relFromVault = relative(vaultDir, destPath);
+  const kindDir = relFromVault.split('/').filter(Boolean);
+  let kind =
+    meta.kind || (kindDir.length >= 2 ? kindDir[kindDir.length - 2] : kindDir[0]) || 'note';
+
+  const parsed = parseEntryFromMarkdown(kind, rawBody, meta);
+  const category = categoryFor(kind);
+
+  await indexEntry(ctx, {
+    id: meta.id || entryId,
+    kind,
+    category,
+    title: parsed.title,
+    body: parsed.body,
+    meta: parsed.meta,
+    tags: Array.isArray(meta.tags) ? meta.tags : null,
+    source: meta.source || 'archive-restore',
+    filePath: destPath,
+    createdAt: meta.created || new Date().toISOString(),
+    identity_key: meta.identity_key || null,
+    expires_at: meta.expires_at || null,
+    tier: meta.tier || defaultTierFor(kind),
+  });
+
+  return { restored: true, filePath: destPath, kind, id: meta.id || entryId };
+}
+
+export function countArchivedEntries(vaultDir) {
+  const archRoot = archiveDir(vaultDir);
+  if (!existsSync(archRoot)) return 0;
+  try {
+    return walkDir(archRoot).length;
+  } catch {
+    return 0;
+  }
+}
+
+export function listArchivedEntries(vaultDir) {
+  const archRoot = archiveDir(vaultDir);
+  if (!existsSync(archRoot)) return [];
+
+  const entries = [];
+  try {
+    const mdFiles = walkDir(archRoot);
+    for (const { filePath, relDir } of mdFiles) {
+      try {
+        const raw = readFileSync(filePath, 'utf-8');
+        const { meta, body } = parseFrontmatter(raw);
+        entries.push({
+          id: meta.id || null,
+          kind: relDir?.split('/').pop() || 'unknown',
+          title: meta.title || body.slice(0, 80),
+          tags: meta.tags || [],
+          created: meta.created || null,
+          filePath,
+        });
+      } catch {
+        continue;
+      }
+    }
+  } catch {}
+  return entries;
+}

package/src/error-log.js

@@ -5,13 +5,13 @@ import {
   readFileSync,
   statSync,
   writeFileSync,
-} from "node:fs";
-import { join } from "node:path";
+} from 'node:fs';
+import { join } from 'node:path';
 
 const MAX_LOG_SIZE = 1024 * 1024;
 
 export function errorLogPath(dataDir) {
-  return join(dataDir, "error.log");
+  return join(dataDir, 'error.log');
 }
 
 export function appendErrorLog(dataDir, entry) {
@@ -19,9 +19,9 @@ export function appendErrorLog(dataDir, entry) {
     mkdirSync(dataDir, { recursive: true });
     const logPath = errorLogPath(dataDir);
     if (existsSync(logPath) && statSync(logPath).size >= MAX_LOG_SIZE) {
-      writeFileSync(logPath, "");
+      writeFileSync(logPath, '');
     }
-    appendFileSync(logPath, JSON.stringify(entry) + "\n");
+    appendFileSync(logPath, JSON.stringify(entry) + '\n');
   } catch {
     // intentionally swallowed
   }
@@ -31,8 +31,8 @@ export function errorLogCount(dataDir) {
   try {
     const logPath = errorLogPath(dataDir);
     if (!existsSync(logPath)) return 0;
-    return readFileSync(logPath, "utf-8")
-      .split("\n")
+    return readFileSync(logPath, 'utf-8')
+      .split('\n')
       .filter((l) => l.trim()).length;
   } catch {
     return 0;

package/src/helpers.js

@@ -1,19 +1,17 @@
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const pkg = JSON.parse(
-  readFileSync(join(__dirname, "..", "package.json"), "utf-8"),
-);
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
 
 export function ok(text) {
-  return { content: [{ type: "text", text }] };
+  return { content: [{ type: 'text', text }] };
 }
 
-export function err(text, code = "UNKNOWN", meta = {}) {
+export function err(text, code = 'UNKNOWN', meta = {}) {
   return {
-    content: [{ type: "text", text }],
+    content: [{ type: 'text', text }],
     isError: true,
     code,
     _meta: {
@@ -29,7 +27,7 @@ export function err(text, code = "UNKNOWN", meta = {}) {
 export function errWithHint(text, code, hint) {
   const prompt = hint
     ? `\n\n**Debug with AI:** Paste this into Claude Code or your AI assistant:\n> "${hint}"`
-    : "";
+    : '';
   return err(text + prompt, code);
 }
 
@@ -37,8 +35,8 @@ export function ensureVaultExists(config) {
   if (!config.vaultDirExists) {
     return errWithHint(
       `Vault directory not found: ${config.vaultDir}. Run context-status for diagnostics.`,
-      "VAULT_NOT_FOUND",
-      "My context-vault can't find the vault directory. Run `context-vault doctor` and help me fix it.",
+      'VAULT_NOT_FOUND',
+      "My context-vault can't find the vault directory. Run `context-vault doctor` and help me fix it."
     );
   }
   return null;
@@ -48,7 +46,7 @@ export function ensureValidKind(kind) {
   if (!/^[a-z][a-z0-9_-]*$/.test(kind)) {
     return err(
       "Required: kind (lowercase alphanumeric, e.g. 'insight', 'reference')",
-      "INVALID_KIND",
+      'INVALID_KIND'
     );
   }
   return null;

package/src/linking.js

@@ -3,7 +3,7 @@ export function parseRelatedTo(raw) {
   try {
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) return [];
-    return parsed.filter((id) => typeof id === "string" && id.trim());
+    return parsed.filter((id) => typeof id === 'string' && id.trim());
   } catch {
     return [];
   }
@@ -12,14 +12,14 @@ export function parseRelatedTo(raw) {
 export function resolveLinks(db, ids) {
   if (!ids.length) return [];
   const unique = [...new Set(ids)];
-  const placeholders = unique.map(() => "?").join(",");
+  const placeholders = unique.map(() => '?').join(',');
   try {
     return db
       .prepare(
         `SELECT * FROM vault
          WHERE id IN (${placeholders})
            AND (expires_at IS NULL OR expires_at > datetime('now'))
-           AND superseded_by IS NULL`,
+           AND superseded_by IS NULL`
       )
       .all(...unique);
   } catch {
@@ -36,7 +36,7 @@ export function resolveBacklinks(db, entryId) {
         `SELECT * FROM vault
          WHERE related_to LIKE ?
            AND (expires_at IS NULL OR expires_at > datetime('now'))
-           AND superseded_by IS NULL`,
+           AND superseded_by IS NULL`
       )
       .all(likePattern);
   } catch {
@@ -54,9 +54,7 @@ export function collectLinkedEntries(db, primaryEntries) {
       if (!primaryIds.has(id)) forwardIds.push(id);
     }
   }
-  const forwardEntries = resolveLinks(db, forwardIds).filter(
-    (e) => !primaryIds.has(e.id),
-  );
+  const forwardEntries = resolveLinks(db, forwardIds).filter((e) => !primaryIds.has(e.id));
 
   const backwardSeen = new Set();
   const backwardEntries = [];
@@ -75,11 +73,10 @@ export function collectLinkedEntries(db, primaryEntries) {
 
 export function validateRelatedTo(relatedTo) {
   if (relatedTo === undefined || relatedTo === null) return null;
-  if (!Array.isArray(relatedTo))
-    return "related_to must be an array of entry IDs";
+  if (!Array.isArray(relatedTo)) return 'related_to must be an array of entry IDs';
   for (const id of relatedTo) {
-    if (typeof id !== "string" || !id.trim()) {
-      return "each related_to entry must be a non-empty string ID";
+    if (typeof id !== 'string' || !id.trim()) {
+      return 'each related_to entry must be a non-empty string ID';
     }
     if (id.length > 32) {
       return `related_to ID too long (max 32 chars): "${id.slice(0, 32)}..."`;

package/src/migrate-dirs.js

@@ -0,0 +1,139 @@
+import {
+  existsSync,
+  readdirSync,
+  mkdirSync,
+  renameSync,
+  copyFileSync,
+  rmSync,
+  statSync,
+} from 'node:fs';
+import { join } from 'node:path';
+
+export const PLURAL_TO_SINGULAR = {
+  insights: 'insight',
+  decisions: 'decision',
+  patterns: 'pattern',
+  statuses: 'status',
+  analyses: 'analysis',
+  contacts: 'contact',
+  projects: 'project',
+  tools: 'tool',
+  sources: 'source',
+  conversations: 'conversation',
+  messages: 'message',
+  sessions: 'session',
+  logs: 'log',
+  feedbacks: 'feedback',
+  notes: 'note',
+  prompts: 'prompt',
+  documents: 'document',
+  references: 'reference',
+  tasks: 'task',
+  buckets: 'bucket',
+  architectures: 'architecture',
+  briefs: 'brief',
+  companies: 'company',
+  discoveries: 'discovery',
+  events: 'event',
+  ideas: 'idea',
+  issues: 'issue',
+  agents: 'agent',
+  'session-summaries': 'session-summary',
+  'session-reviews': 'session-review',
+  'user-prompts': 'user-prompt',
+};
+
+const CATEGORY_DIRS = ['knowledge', 'entities', 'events'];
+
+function countMdFiles(dir) {
+  let count = 0;
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        count += countMdFiles(join(dir, entry.name));
+      } else if (entry.isFile() && entry.name.endsWith('.md')) {
+        count++;
+      }
+    }
+  } catch {}
+  return count;
+}
+
+export function planMigration(vaultDir) {
+  const ops = [];
+
+  for (const catName of CATEGORY_DIRS) {
+    const catDir = join(vaultDir, catName);
+    if (!existsSync(catDir) || !statSync(catDir).isDirectory()) continue;
+
+    let entries;
+    try {
+      entries = readdirSync(catDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const dirName = entry.name;
+      const singular = PLURAL_TO_SINGULAR[dirName];
+      if (!singular) continue;
+
+      const pluralDir = join(catDir, dirName);
+      const singularDir = join(catDir, singular);
+      if (pluralDir === singularDir) continue;
+
+      const fileCount = countMdFiles(pluralDir);
+      const singularExists = existsSync(singularDir);
+
+      ops.push({
+        action: singularExists ? 'merge' : 'rename',
+        pluralDir,
+        singularDir,
+        pluralName: dirName,
+        singularName: singular,
+        fileCount,
+      });
+    }
+  }
+
+  return ops;
+}
+
+function mergeDir(src, dst) {
+  mkdirSync(dst, { recursive: true });
+  for (const entry of readdirSync(src, { withFileTypes: true })) {
+    const srcPath = join(src, entry.name);
+    const dstPath = join(dst, entry.name);
+    if (entry.isDirectory()) {
+      mergeDir(srcPath, dstPath);
+    } else if (entry.isFile()) {
+      if (!existsSync(dstPath)) {
+        copyFileSync(srcPath, dstPath);
+      }
+    }
+  }
+}
+
+export function executeMigration(ops) {
+  let renamed = 0;
+  let merged = 0;
+  const errors = [];
+
+  for (const op of ops) {
+    try {
+      if (op.action === 'rename') {
+        renameSync(op.pluralDir, op.singularDir);
+        renamed++;
+      } else {
+        mergeDir(op.pluralDir, op.singularDir);
+        rmSync(op.pluralDir, { recursive: true, force: true });
+        merged++;
+      }
+    } catch (e) {
+      errors.push(`${op.pluralName} → ${op.singularName}: ${e.message}`);
+    }
+  }
+
+  return { renamed, merged, errors };
+}