context-vault 3.0.1 → 3.0.3

package/bin/cli.js

@@ -3308,7 +3308,7 @@ async function runRecall() {
     const { initDatabase, prepareStatements } =
       await import("@context-vault/core/db");
     const { embed } = await import("@context-vault/core/embed");
-    const { hybridSearch } = await import("@context-vault/core/retrieve/index");
+    const { hybridSearch } = await import("@context-vault/core/search");
 
     db = await initDatabase(config.dbPath);
     const stmts = prepareStatements(db);
@@ -3436,13 +3436,158 @@ async function runSessionCapture() {
 }
 
 async function runSessionEnd() {
-  const { main } = await import("../src/hooks/session-end.mjs");
-  await main();
+  let db;
+  try {
+    const raw = await new Promise((resolve) => {
+      let data = "";
+      process.stdin.on("data", (chunk) => (data += chunk));
+      process.stdin.on("end", () => resolve(data));
+    });
+    if (!raw.trim()) return;
+    let input;
+    try {
+      input = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    const { session_id, transcript_path, cwd } = input ?? {};
+    if (!transcript_path || !cwd) return;
+
+    // Read transcript (JSONL)
+    let turns = [];
+    try {
+      const transcriptRaw = readFileSync(transcript_path, "utf-8");
+      for (const line of transcriptRaw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try { turns.push(JSON.parse(trimmed)); } catch {}
+      }
+    } catch { return; }
+
+    const extractText = (turn) => {
+      if (typeof turn.content === "string") return turn.content;
+      if (Array.isArray(turn.content))
+        return turn.content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
+      return "";
+    };
+
+    const userTurns = turns.filter((t) => t.role === "user");
+    if (userTurns.length === 0) return;
+
+    // Tool use blocks
+    const allToolUse = [];
+    for (const turn of turns) {
+      if (!Array.isArray(turn.content)) continue;
+      for (const block of turn.content) {
+        if (block.type === "tool_use") allToolUse.push(block);
+      }
+    }
+
+    // Files modified
+    const seenFiles = new Set();
+    const filesModified = [];
+    for (const block of allToolUse) {
+      if (block.name === "Write" || block.name === "Edit") {
+        const path = block.input?.file_path ?? block.input?.path ?? null;
+        if (path && !seenFiles.has(path)) { seenFiles.add(path); filesModified.push(path); }
+      }
+    }
+
+    // Commands run
+    const commandsRun = [];
+    for (const block of allToolUse) {
+      if (block.name === "Bash") {
+        const cmd = block.input?.command ?? block.input?.cmd ?? null;
+        if (cmd) commandsRun.push(cmd.slice(0, 100));
+      }
+    }
+
+    // Tool counts
+    const toolCounts = {};
+    for (const block of allToolUse) {
+      const name = block.name ?? "unknown";
+      toolCounts[name] = (toolCounts[name] ?? 0) + 1;
+    }
+    const toolSummary = Object.entries(toolCounts)
+      .sort((a, b) => b[1] - a[1])
+      .map(([name, count]) => `${name}: ${count}`)
+      .join(", ");
+
+    // Duration
+    let durationStr = null;
+    const timestampedTurns = turns.filter((t) => t.timestamp != null);
+    if (timestampedTurns.length >= 2) {
+      const diffMs = new Date(timestampedTurns[timestampedTurns.length - 1].timestamp) - new Date(timestampedTurns[0].timestamp);
+      if (!isNaN(diffMs) && diffMs >= 0) {
+        const totalSec = Math.round(diffMs / 1000);
+        const hours = Math.floor(totalSec / 3600);
+        const minutes = Math.floor((totalSec % 3600) / 60);
+        const seconds = totalSec % 60;
+        durationStr = hours > 0 ? `${hours}h ${minutes}m` : minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+      }
+    }
+
+    const message_count = userTurns.length;
+    const project = cwd.split("/").pop() || "unknown";
+    const first_prompt = extractText(userTurns[0]).slice(0, 200);
+    const last_prompt = message_count > 1 ? extractText(userTurns[message_count - 1]).slice(0, 200) : first_prompt;
+
+    // Build body
+    const durationPart = durationStr ? `, ~${durationStr}` : "";
+    const bodyLines = [
+      `Session in ${project} (${message_count} exchange${message_count !== 1 ? "s" : ""}${durationPart}).`,
+      "", "## What was done",
+      `Opened with: ${first_prompt}`, "",
+      `Closed with: ${last_prompt}`,
+    ];
+    const limitedFiles = filesModified.slice(0, 20);
+    if (limitedFiles.length > 0) {
+      bodyLines.push("", "## Files modified");
+      for (const f of limitedFiles) bodyLines.push(`- ${f}`);
+      if (filesModified.length > 20) bodyLines.push(`- ... and ${filesModified.length - 20} more`);
+    }
+    const limitedCmds = commandsRun.slice(0, 10);
+    if (limitedCmds.length > 0) {
+      bodyLines.push("", "## Key commands");
+      for (const c of limitedCmds) bodyLines.push(`- ${c}`);
+      if (commandsRun.length > 10) bodyLines.push(`- ... and ${commandsRun.length - 10} more`);
+    }
+    if (toolSummary) bodyLines.push("", "## Tools used", toolSummary);
+    const body = bodyLines.join("\n");
+
+    // Save via core APIs
+    const { resolveConfig } = await import("@context-vault/core/config");
+    const config = resolveConfig();
+    if (!config.vaultDirExists) return;
+    const { initDatabase, prepareStatements, insertVec, deleteVec } =
+      await import("@context-vault/core/db");
+    const { captureAndIndex } = await import("@context-vault/core/capture");
+    db = await initDatabase(config.dbPath);
+    const stmts = prepareStatements(db);
+    const ctx = {
+      db, config, stmts,
+      embed: async () => null,
+      insertVec: (rowid, embedding) => insertVec(stmts, rowid, embedding),
+      deleteVec: (rowid) => deleteVec(stmts, rowid),
+    };
+    const entry = await captureAndIndex(ctx, {
+      kind: "session",
+      title: `Session — ${project} ${new Date().toLocaleString("en-US", { month: "short", day: "numeric", year: "numeric", hour: "2-digit", minute: "2-digit" })}`,
+      body,
+      tags: ["session-end", "session-summary", project],
+      source: "claude-code",
+      meta: { session_id: session_id ?? null, cwd, message_count },
+    });
+    console.log(`context-vault session captured — id: ${entry.id}`);
+  } catch {
+    // fail silently — never block session end
+  } finally {
+    try { db?.close(); } catch {}
+  }
 }
 
 async function runPostToolCall() {
-  const { main } = await import("../src/hooks/post-tool-call.mjs");
-  await main();
+  // Removed in v3 — post-tool-call hooks are no longer supported
 }
 
 async function runSave() {
@@ -3453,6 +3598,8 @@ async function runSave() {
   const tier = getFlag("--tier");
   const filePath = getFlag("--file");
   const bodyFlag = getFlag("--body");
+  const identityKey = getFlag("--identity-key");
+  const metaRaw = getFlag("--meta");
 
   if (!kind) {
     console.error(red("Error: --kind is required"));
@@ -3463,6 +3610,16 @@ async function runSave() {
     process.exit(1);
   }
 
+  let meta;
+  if (metaRaw) {
+    try {
+      meta = JSON.parse(metaRaw);
+    } catch {
+      console.error(red("Error: --meta must be valid JSON"));
+      process.exit(1);
+    }
+  }
+
   let body;
   if (bodyFlag) {
     body = bodyFlag;
@@ -3520,6 +3677,8 @@ async function runSave() {
       tags: parsedTags,
       source,
       ...(tier ? { tier } : {}),
+      ...(identityKey ? { identity_key: identityKey } : {}),
+      ...(meta !== undefined ? { meta } : {}),
     });
     console.log(`${green("✓")} Saved ${kind} — id: ${entry.id}`);
   } catch (e) {
@@ -3579,7 +3738,7 @@ async function runSearch() {
     const { initDatabase, prepareStatements } =
       await import("@context-vault/core/db");
     const { embed } = await import("@context-vault/core/embed");
-    const { hybridSearch } = await import("@context-vault/core/retrieve/index");
+    const { hybridSearch } = await import("@context-vault/core/search");
 
     db = await initDatabase(config.dbPath);
     const stmts = prepareStatements(db);

package/node_modules/@context-vault/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@context-vault/core",
-  "version": "3.0.0",
+  "version": "3.0.3",
   "type": "module",
   "description": "Pure local engine: capture, index, search, and utilities for context-vault",
   "main": "dist/main.js",

package/node_modules/@context-vault/core/src/capture.ts

@@ -266,7 +266,7 @@ export function updateEntryFile(
   };
 }
 
-export async function captureAndIndex(ctx: BaseCtx, data: CaptureInput): Promise<CaptureResult> {
+export async function captureAndIndex(ctx: BaseCtx, data: CaptureInput, precomputedEmbedding?: Float32Array | null): Promise<CaptureResult> {
   let previousContent: string | null = null;
   if (categoryFor(data.kind) === "entity" && data.identity_key) {
     const identitySlug = slugify(data.identity_key);
@@ -279,7 +279,7 @@ export async function captureAndIndex(ctx: BaseCtx, data: CaptureInput): Promise
 
   const entry = writeEntry(ctx, data);
   try {
-    await indexEntry(ctx, entry);
+    await indexEntry(ctx, entry, precomputedEmbedding);
     if (entry.supersedes?.length && ctx.stmts.updateSupersededBy) {
       for (const supersededId of entry.supersedes) {
         if (typeof supersededId === "string" && supersededId.trim()) {

package/node_modules/@context-vault/core/src/index.ts

@@ -13,6 +13,7 @@ const EMBED_BATCH_SIZE = 32;
 export async function indexEntry(
   ctx: BaseCtx,
   entry: IndexEntryInput & { supersedes?: string[] | null; related_to?: string[] | null },
+  precomputedEmbedding?: Float32Array | null,
 ): Promise<void> {
   const {
     id, kind, category, title, body, meta, tags, source,
@@ -92,8 +93,9 @@ export async function indexEntry(
   }
 
   if (cat !== "event") {
-    const embeddingText = [title, body].filter(Boolean).join(" ");
-    const embedding = await ctx.embed(embeddingText);
+    const embedding = precomputedEmbedding !== undefined
+      ? precomputedEmbedding
+      : await ctx.embed([title, body].filter(Boolean).join(" "));
 
     if (embedding) {
       try { ctx.deleteVec(rowid); } catch { /* no-op */ }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-vault",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "type": "module",
   "description": "Persistent memory for AI agents — saves and searches knowledge across sessions",
   "bin": {
@@ -57,7 +57,7 @@
     "@context-vault/core"
   ],
   "dependencies": {
-    "@context-vault/core": "^3.0.0",
+    "@context-vault/core": "^3.0.3",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "adm-zip": "^0.5.16",
     "sqlite-vec": "^0.1.0"

package/src/register-tools.js

@@ -170,4 +170,6 @@ export function registerTools(server, ctx) {
       tracked((args) => mod.handler(args, ctx, shared), mod.name),
     );
   }
+
+  ensureIndexed().catch(() => {});
 }

package/src/tools/save-context.js

@@ -484,17 +484,18 @@ export async function handler(
   // ── Similarity check (knowledge + event only) ────────────────────────────
   const category = categoryFor(normalizedKind);
   let similarEntries = [];
+  let queryEmbedding = null;
 
   if (category === "knowledge" || category === "event") {
     const threshold = similarity_threshold ?? DEFAULT_SIMILARITY_THRESHOLD;
     const embeddingText = [title, body].filter(Boolean).join(" ");
-    const queryEmbedding = await ctx.embed(embeddingText);
+    queryEmbedding = await ctx.embed(embeddingText);
     if (queryEmbedding) {
       similarEntries = await findSimilar(
         ctx,
         queryEmbedding,
         threshold,
-        
+
         { hydrate: suggestMode },
       );
     }
@@ -540,6 +541,8 @@ export async function handler(
 
   const effectiveTier = tier ?? defaultTierFor(normalizedKind);
 
+  const embeddingToReuse = category === "knowledge" ? queryEmbedding : null;
+
   const entry = await captureAndIndex(ctx, {
     kind: normalizedKind,
     title,
@@ -553,9 +556,9 @@ export async function handler(
     supersedes,
     related_to,
     source_files,
-    
+
     tier: effectiveTier,
-  });
+  }, embeddingToReuse);
 
   if (ctx.config?.dataDir) {
     maybeShowFeedbackPrompt(ctx.config.dataDir);