context-vault 3.8.0 → 3.9.0

package/src/tools/recall.ts

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import { ok } from '../helpers.js';
 import { isEmbedAvailable } from '@context-vault/core/embed';
+import { getAutoMemory, findAutoMemoryOverlaps } from '../auto-memory.js';
+import { getRemoteClient, getTeamId } from '../remote.js';
 import type { LocalCtx, SharedCtx, ToolResult } from '../types.js';
 
 const SEMANTIC_SIMILARITY_THRESHOLD = 0.6;
@@ -173,6 +175,58 @@ export async function handler(
     if (sessionSet) sessionSet.add(row.id);
   }
 
+  // Remote recall: merge hints from hosted API
+  const remoteClient = getRemoteClient(ctx.config);
+  if (remoteClient && hints.length < limit) {
+    try {
+      const remoteHints = await remoteClient.recall({
+        signal,
+        signal_type,
+        bucket,
+        max_hints: limit - hints.length,
+      });
+      const localIds = new Set(hints.map(h => h.id));
+      for (const rh of remoteHints) {
+        if (hints.length >= limit) break;
+        if (localIds.has(rh.id)) continue;
+        if (sessionSet && !bypassDedup && sessionSet.has(rh.id)) {
+          suppressed++;
+          continue;
+        }
+        hints.push(rh);
+        if (sessionSet) sessionSet.add(rh.id);
+      }
+    } catch (e) {
+      console.warn(`[context-vault] Remote recall failed: ${(e as Error).message}`);
+    }
+  }
+
+  // Team vault recall: include team results if teamId is configured
+  const teamId = getTeamId(ctx.config);
+  if (remoteClient && teamId && hints.length < limit) {
+    try {
+      const teamHints = await remoteClient.teamRecall(teamId, {
+        signal,
+        signal_type,
+        bucket,
+        max_hints: limit - hints.length,
+      });
+      const existingIds = new Set(hints.map(h => h.id));
+      for (const th of teamHints) {
+        if (hints.length >= limit) break;
+        if (existingIds.has(th.id)) continue;
+        if (sessionSet && !bypassDedup && sessionSet.has(th.id)) {
+          suppressed++;
+          continue;
+        }
+        hints.push({ ...th, tags: [...(th.tags || []), '[team]'] });
+        if (sessionSet) sessionSet.add(th.id);
+      }
+    } catch (e) {
+      console.warn(`[context-vault] Team recall failed: ${(e as Error).message}`);
+    }
+  }
+
   let method: 'tag_match' | 'semantic' | 'none' = hints.length > 0 ? 'tag_match' : 'none';
 
   // Semantic fallback: when fast-path returns 0 results and signal is not file-based
@@ -265,10 +319,33 @@ export async function handler(
     recordCoRetrieval(ctx, hints.map((h) => h.id));
   }
 
+  // Check for auto-memory overlap to avoid redundant surfacing
+  let autoMemoryOverlaps: Array<{ hint_id: string; memory_file: string; memory_name: string }> = [];
+  try {
+    const autoMemory = getAutoMemory();
+    if (autoMemory.detected && autoMemory.entries.length > 0) {
+      for (const h of hints) {
+        const searchText = [h.title, h.summary].filter(Boolean).join(' ');
+        const overlaps = findAutoMemoryOverlaps(autoMemory, searchText, 0.3);
+        if (overlaps.length > 0) {
+          autoMemoryOverlaps.push({
+            hint_id: h.id,
+            memory_file: overlaps[0].file,
+            memory_name: overlaps[0].name,
+          });
+        }
+      }
+    }
+  } catch {
+    // Non-fatal
+  }
+
   // Format output
   const lines = [`[Vault: ${hints.length} ${hints.length === 1 ? 'entry' : 'entries'} may be relevant]`];
   for (const h of hints) {
-    lines.push(`- "${h.title}" (${h.kind}, ${h.relevance})`);
+    const overlap = autoMemoryOverlaps.find(o => o.hint_id === h.id);
+    const overlapNote = overlap ? ` [also in auto-memory: ${overlap.memory_name}]` : '';
+    lines.push(`- "${h.title}" (${h.kind}, ${h.relevance})${overlapNote}`);
   }
   lines.push('Use get_context to retrieve full details.');
 
@@ -279,6 +356,7 @@ export async function handler(
     signal_keywords: keywords,
     suppressed,
     hints,
+    auto_memory_overlaps: autoMemoryOverlaps.length > 0 ? autoMemoryOverlaps : undefined,
   };
   return result;
 }

package/src/tools/save-context.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
 import { resolve, basename, join } from 'node:path';
 import { homedir } from 'node:os';
-import { captureAndIndex, updateEntryFile } from '@context-vault/core/capture';
+import { captureAndIndex, updateEntryFile, writeEntry } from '@context-vault/core/capture';
 import { indexEntry } from '@context-vault/core/index';
 import { categoryFor, defaultTierFor } from '@context-vault/core/categories';
 import { normalizeKind, kindToPath } from '@context-vault/core/files';
@@ -11,6 +11,8 @@ import { shouldIndex } from '@context-vault/core/indexing';
 import { ok, err, errWithHint, ensureVaultExists, ensureValidKind, kindIcon } from '../helpers.js';
 import { maybeShowFeedbackPrompt } from '../telemetry.js';
 import { validateRelatedTo } from '../linking.js';
+import { getAutoMemory, findAutoMemoryOverlaps } from '../auto-memory.js';
+import { getRemoteClient, getTeamId } from '../remote.js';
 import type { LocalCtx, SharedCtx, ToolResult } from '../types.js';
 import {
   MAX_BODY_LENGTH,
@@ -39,6 +41,17 @@ function isDualWriteEnabled(config: { dataDir: string }): boolean {
   }
 }
 
+function isDeferredSyncEnabled(config: { dataDir: string }): boolean {
+  try {
+    const configPath = join(config.dataDir, 'config.json');
+    if (!existsSync(configPath)) return false;
+    const fc = JSON.parse(readFileSync(configPath, 'utf-8'));
+    return fc.dualWrite?.deferredSync === true;
+  } catch {
+    return false;
+  }
+}
+
 function dualWriteLocal(entryFilePath: string, kind: string): void {
   const cwd = process.cwd();
   const home = homedir();
@@ -375,6 +388,12 @@ export const inputSchema = {
     .describe(
       'Whether to index this entry for search (generate embeddings + FTS). Default: auto-determined by indexing config. Set to false to store file + metadata only, skipping embedding generation. Set to true to force indexing regardless of config rules.'
     ),
+  visibility: z
+    .enum(['personal', 'team'])
+    .optional()
+    .describe(
+      'Where to save: "personal" (default) saves to local + personal remote. "team" publishes to the team vault instead via POST /api/vault/publish. Requires teamId in remote config or a prior `context-vault team join`.'
+    ),
 };
 
 export async function handler(
@@ -398,6 +417,7 @@ export async function handler(
     conflict_resolution,
     encoding_context,
     indexed,
+    visibility,
   }: Record<string, any>,
   ctx: LocalCtx,
   { ensureIndexed }: SharedCtx
@@ -511,6 +531,22 @@ export async function handler(
       dualWriteLocal(entry.filePath, entry.kind);
     }
 
+    // Remote sync for updates: fire-and-forget PUT to hosted API
+    const updateRemoteClient = getRemoteClient(config);
+    if (updateRemoteClient) {
+      updateRemoteClient.saveEntry({
+        id: entry.id,
+        kind: entry.kind,
+        title: entry.title,
+        body: entry.body,
+        tags: entry.tags,
+        meta: entry.meta,
+        source: entry.source,
+      }).catch((e: Error) => {
+        console.warn(`[context-vault] Remote sync (update) failed: ${e.message}`);
+      });
+    }
+
     const relPath = entry.filePath
       ? entry.filePath.replace(config.vaultDir + '/', '')
       : entry.filePath;
@@ -535,6 +571,68 @@ export async function handler(
     return err(`Entity kind "${normalizedKind}" requires identity_key`, 'MISSING_IDENTITY_KEY');
   }
 
+  // ── Deferred sync: file-only write, skip DB entirely ──────────────────
+  if (isDeferredSyncEnabled(config)) {
+    const category = categoryFor(normalizedKind);
+    const effectiveTier = tier ?? defaultTierFor(normalizedKind);
+    const mergedMeta = { ...(meta || {}) };
+    if (folder) mergedMeta.folder = folder;
+    const parsedCtx = parseContextParam(encoding_context);
+    if (parsedCtx?.structured) {
+      mergedMeta.encoding_context = parsedCtx.structured;
+    } else if (parsedCtx?.text) {
+      mergedMeta.encoding_context = parsedCtx.text;
+    }
+    if (normalizedKind === 'decision') {
+      enrichDecisionMeta(mergedMeta, title, body);
+    }
+    const finalMeta = Object.keys(mergedMeta).length ? mergedMeta : undefined;
+
+    let entry;
+    try {
+      entry = writeEntry(ctx, {
+        kind: normalizedKind,
+        title,
+        body,
+        meta: finalMeta,
+        tags,
+        source,
+        folder,
+        identity_key,
+        expires_at,
+        supersedes,
+        related_to,
+        source_files,
+        tier: effectiveTier,
+        indexed: false,
+      });
+    } catch (e) {
+      return errWithHint(
+        e instanceof Error ? e.message : String(e),
+        'SAVE_FAILED',
+        'context-vault save_context is failing. Check `cat ~/.context-mcp/error.log | tail -5` and help me debug.'
+      );
+    }
+
+    if (isDualWriteEnabled(config) && entry.filePath) {
+      dualWriteLocal(entry.filePath, normalizedKind);
+    }
+
+    const relPath = entry.filePath
+      ? entry.filePath.replace(config.vaultDir + '/', '')
+      : entry.filePath;
+    const icon = kindIcon(normalizedKind);
+    const parts = [
+      `## ✓ Saved (deferred)`,
+      `${icon} **${title || '(untitled)'}**`,
+      `\`${normalizedKind}\` · **${effectiveTier}**${tags?.length ? ` · ${tags.join(', ')}` : ''}`,
+      `\`${entry.id}\` → ${relPath}`,
+      '',
+      '_Deferred sync: file written, not yet indexed. Run `vault sync` to index._',
+    ];
+    return ok(parts.join('\n'));
+  }
+
   // Start reindex in background but don't wait — similarity check
   // may miss unindexed entries, but the save won't time out
   await ensureIndexed({ blocking: false });
@@ -680,6 +778,56 @@ export async function handler(
     dualWriteLocal(entry.filePath, normalizedKind);
   }
 
+  // Remote sync: fire-and-forget POST to hosted API
+  const remoteClient = getRemoteClient(config);
+  if (visibility === 'team') {
+    const effectiveTeamId = getTeamId(config);
+    if (!remoteClient) {
+      console.warn('[context-vault] Team publish skipped: remote not configured');
+    } else if (!effectiveTeamId) {
+      console.warn('[context-vault] Team publish skipped: no teamId configured');
+    } else if (category === 'event') {
+      console.warn('[context-vault] Team publish skipped: events are private');
+    } else {
+      remoteClient.publishToTeam({
+        entryId: entry.id,
+        teamId: effectiveTeamId,
+        visibility: 'team',
+        entry: {
+          kind: normalizedKind,
+          title,
+          body,
+          tags,
+          meta: finalMeta,
+          source,
+          identity_key,
+          tier: effectiveTier,
+          category,
+        },
+      }).catch((e: Error) => {
+        console.warn(`[context-vault] Team publish failed: ${e.message}`);
+      });
+    }
+  } else if (remoteClient) {
+    remoteClient.saveEntry({
+      id: entry.id,
+      kind: normalizedKind,
+      title,
+      body,
+      tags,
+      meta: finalMeta,
+      source,
+      identity_key,
+      expires_at,
+      supersedes,
+      related_to,
+      source_files,
+      tier: effectiveTier,
+    }).catch((e: Error) => {
+      console.warn(`[context-vault] Remote sync failed: ${e.message}`);
+    });
+  }
+
   if (ctx.config?.dataDir) {
     maybeShowFeedbackPrompt(ctx.config.dataDir);
   }
@@ -750,6 +898,24 @@ export async function handler(
     }
   }
 
+  // Auto-memory overlap detection (advisory)
+  try {
+    const autoMemory = getAutoMemory();
+    if (autoMemory.detected && autoMemory.entries.length > 0) {
+      const searchText = [title, body].filter(Boolean).join(' ');
+      const overlaps = findAutoMemoryOverlaps(autoMemory, searchText, 0.3);
+      if (overlaps.length > 0) {
+        const top = overlaps[0];
+        parts.push('');
+        parts.push(`### Auto-Memory Overlap`);
+        parts.push(`Similar content found in auto-memory: **${top.name}** (\`${top.file}\`, ${top.type} type, ${(top.similarity * 100).toFixed(0)}% overlap)`);
+        parts.push(`_This knowledge already exists in your auto-memory. Consider whether vault storage adds cross-project value._`);
+      }
+    }
+  } catch {
+    // Non-fatal: auto-memory overlap check should not block save
+  }
+
   const criticalLimit = config.thresholds?.totalEntries?.critical;
   if (criticalLimit != null) {
     try {

package/src/tools/session-start.ts

@@ -4,6 +4,9 @@ import { readFileSync, readdirSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { ok, err, ensureVaultExists, kindIcon, fmtDate } from '../helpers.js';
+import { getAutoMemory } from '../auto-memory.js';
+import { getRemoteClient, getTeamId } from '../remote.js';
+import type { AutoMemoryEntry, AutoMemoryResult } from '../auto-memory.js';
 import type { LocalCtx, SharedCtx, ToolResult } from '../types.js';
 
 const DEFAULT_MAX_TOKENS = 4000;
@@ -12,99 +15,6 @@ const MAX_BODY_PER_ENTRY = 400;
 const PRIORITY_KINDS = ['decision', 'insight', 'pattern'];
 const SESSION_SUMMARY_KIND = 'session';
 
-interface AutoMemoryEntry {
-  file: string;
-  name: string;
-  description: string;
-  type: string;
-  body: string;
-}
-
-interface AutoMemoryResult {
-  detected: boolean;
-  path: string | null;
-  entries: AutoMemoryEntry[];
-  linesUsed: number;
-}
-
-/**
- * Detect the Claude Code auto-memory directory for the current project.
- * Convention: ~/.claude/projects/-<cwd-with-slashes-replaced-by-dashes>/memory/
- */
-function detectAutoMemoryPath(): string | null {
-  try {
-    const cwd = process.cwd();
-    // Claude Code project key: absolute path with / replaced by -, leading - kept
-    const projectKey = cwd.replace(/\//g, '-');
-    const memoryDir = join(homedir(), '.claude', 'projects', projectKey, 'memory');
-    const memoryIndex = join(memoryDir, 'MEMORY.md');
-    if (existsSync(memoryIndex)) return memoryDir;
-  } catch {}
-  return null;
-}
-
-/**
- * Parse YAML-ish frontmatter from a memory file.
- * Returns { name, description, type } and the body after frontmatter.
- */
-function parseMemoryFile(content: string): { name: string; description: string; type: string; body: string } {
-  const result = { name: '', description: '', type: '', body: content };
-  const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
-  if (!fmMatch) return result;
-
-  const frontmatter = fmMatch[1];
-  result.body = fmMatch[2].trim();
-
-  for (const line of frontmatter.split('\n')) {
-    const kv = line.match(/^(\w+)\s*:\s*(.+)$/);
-    if (!kv) continue;
-    const [, key, val] = kv;
-    if (key === 'name') result.name = val.trim();
-    else if (key === 'description') result.description = val.trim();
-    else if (key === 'type') result.type = val.trim();
-  }
-  return result;
-}
-
-/**
- * Read and parse all auto-memory entries from a memory directory.
- */
-function readAutoMemory(memoryDir: string): AutoMemoryResult {
-  const indexPath = join(memoryDir, 'MEMORY.md');
-  let linesUsed = 0;
-
-  try {
-    const indexContent = readFileSync(indexPath, 'utf-8');
-    linesUsed = indexContent.split('\n').length;
-  } catch {
-    return { detected: true, path: memoryDir, entries: [], linesUsed: 0 };
-  }
-
-  const entries: AutoMemoryEntry[] = [];
-
-  try {
-    const files = readdirSync(memoryDir).filter(
-      (f) => f.endsWith('.md') && f !== 'MEMORY.md'
-    );
-
-    for (const file of files) {
-      try {
-        const content = readFileSync(join(memoryDir, file), 'utf-8');
-        const parsed = parseMemoryFile(content);
-        entries.push({
-          file,
-          name: parsed.name || file.replace('.md', ''),
-          description: parsed.description,
-          type: parsed.type,
-          body: parsed.body,
-        });
-      } catch {}
-    }
-  } catch {}
-
-  return { detected: true, path: memoryDir, entries, linesUsed };
-}
-
 /**
  * Build a search context string from auto-memory entries.
  * Used to boost vault retrieval relevance.
@@ -241,12 +151,7 @@ export async function handler(
   const sinceDate = new Date(Date.now() - RECENT_DAYS * 86400000).toISOString();
 
   // Auto-detect Claude Code auto-memory (explicit path overrides auto-detection)
-  const resolvedMemoryPath = auto_memory_path?.trim()
-    ? (existsSync(join(auto_memory_path.trim(), 'MEMORY.md')) ? auto_memory_path.trim() : null)
-    : detectAutoMemoryPath();
-  const autoMemory: AutoMemoryResult = resolvedMemoryPath
-    ? readAutoMemory(resolvedMemoryPath)
-    : { detected: false, path: null, entries: [], linesUsed: 0 };
+  const autoMemory: AutoMemoryResult = getAutoMemory(auto_memory_path);
   const autoMemoryContext = buildAutoMemoryContext(autoMemory.entries);
   const topicsExtracted = autoMemory.entries.length > 0
     ? extractKeywords(autoMemoryContext).slice(0, 20)
@@ -328,12 +233,95 @@ export async function handler(
     }
   }
 
+  // Remote entries: pull recent from hosted API if configured
+  const remoteClient = getRemoteClient(ctx.config);
+  let remoteCount = 0;
+  if (remoteClient && tokensUsed < tokenBudget) {
+    try {
+      const seenIds = new Set([
+        ...decisions.map((d: any) => d.id),
+        ...deduped.map((d: any) => d.id),
+        ...(lastSession ? [lastSession.id] : []),
+      ]);
+      const remoteTags = effectiveTags.length ? effectiveTags : undefined;
+      const remoteResults = await remoteClient.search({
+        tags: remoteTags,
+        limit: 10,
+        since: sinceDate,
+      });
+      const uniqueRemote = remoteResults.filter((r: any) => !seenIds.has(r.id));
+      if (uniqueRemote.length > 0) {
+        const header = '## Remote Entries\n';
+        const headerTokens = estimateTokens(header);
+        if (tokensUsed + headerTokens <= tokenBudget) {
+          const entryLines: string[] = [];
+          tokensUsed += headerTokens;
+          for (const entry of uniqueRemote) {
+            const line = formatEntry(entry);
+            const lineTokens = estimateTokens(line);
+            if (tokensUsed + lineTokens > tokenBudget) break;
+            entryLines.push(line);
+            tokensUsed += lineTokens;
+            remoteCount++;
+          }
+          if (entryLines.length > 0) {
+            sections.push(header + entryLines.join('\n') + '\n');
+          }
+        }
+      }
+    } catch (e) {
+      console.warn(`[context-vault] Remote session_start failed: ${(e as Error).message}`);
+    }
+  }
+
+  // Team vault entries: include team knowledge in brief if teamId is configured
+  let teamCount = 0;
+  const teamId = getTeamId(ctx.config);
+  if (remoteClient && teamId && tokensUsed < tokenBudget) {
+    try {
+      const allSeenIds = new Set([
+        ...decisions.map((d: any) => d.id),
+        ...deduped.map((d: any) => d.id),
+        ...(lastSession ? [lastSession.id] : []),
+      ]);
+      const teamResults = await remoteClient.teamSearch(teamId, {
+        tags: effectiveTags.length ? effectiveTags : undefined,
+        limit: 10,
+        since: sinceDate,
+      });
+      const uniqueTeam = teamResults.filter((r: any) => !allSeenIds.has(r.id));
+      if (uniqueTeam.length > 0) {
+        const header = '## Team Knowledge\n';
+        const headerTokens = estimateTokens(header);
+        if (tokensUsed + headerTokens <= tokenBudget) {
+          const entryLines: string[] = [];
+          tokensUsed += headerTokens;
+          for (const entry of uniqueTeam) {
+            const line = formatEntry(entry) + ' `[team]`';
+            const lineTokens = estimateTokens(line);
+            if (tokensUsed + lineTokens > tokenBudget) break;
+            entryLines.push(line);
+            tokensUsed += lineTokens;
+            teamCount++;
+          }
+          if (entryLines.length > 0) {
+            sections.push(header + entryLines.join('\n') + '\n');
+          }
+        }
+      }
+    } catch (e) {
+      console.warn(`[context-vault] Team session_start failed: ${(e as Error).message}`);
+    }
+  }
+
   const totalEntries =
     (lastSession ? 1 : 0) +
     decisions.length +
     deduped.filter((_d: any) => {
       return true;
-    }).length;
+    }).length +
+    remoteCount +
+    teamCount;
 
   if (indexWarning) {
     sections.push(indexWarning);