context-vault 3.8.0 → 3.10.0

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, getPublicVaults } 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,140 @@ 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}`);
+    }
+  }
+
+  // Public vault entries: include public knowledge if publicVaults are configured
+  let publicCount = 0;
+  const publicVaultSlugs = getPublicVaults(ctx.config);
+  if (remoteClient && publicVaultSlugs.length > 0 && tokensUsed < tokenBudget) {
+    try {
+      const allPublicSeenIds = new Set([
+        ...decisions.map((d: any) => d.id),
+        ...deduped.map((d: any) => d.id),
+        ...(lastSession ? [lastSession.id] : []),
+      ]);
+      const publicSearches = publicVaultSlugs.map(slug =>
+        remoteClient.publicSearch(slug, {
+          tags: effectiveTags.length ? effectiveTags : undefined,
+          limit: 5,
+          since: sinceDate,
+        }).catch(() => [])
+      );
+      const allPublicResults = await Promise.all(publicSearches);
+      const flatPublic = allPublicResults.flat().filter((r: any) => !allPublicSeenIds.has(r.id));
+      if (flatPublic.length > 0) {
+        const header = '## Public Knowledge\n';
+        const headerTokens = estimateTokens(header);
+        if (tokensUsed + headerTokens <= tokenBudget) {
+          const entryLines: string[] = [];
+          tokensUsed += headerTokens;
+          for (const entry of flatPublic) {
+            const slug = (entry as any).vault_slug || 'public';
+            const line = formatEntry(entry) + ` \`[public:${slug}]\``;
+            const lineTokens = estimateTokens(line);
+            if (tokensUsed + lineTokens > tokenBudget) break;
+            entryLines.push(line);
+            tokensUsed += lineTokens;
+            publicCount++;
+          }
+          if (entryLines.length > 0) {
+            sections.push(header + entryLines.join('\n') + '\n');
+          }
+        }
+      }
+    } catch (e) {
+      console.warn(`[context-vault] Public vault session_start failed: ${(e as Error).message}`);
+    }
+  }
+
   const totalEntries =
     (lastSession ? 1 : 0) +
     decisions.length +
     deduped.filter((_d: any) => {
       return true;
-    }).length;
+    }).length +
+    remoteCount +
+    teamCount +
+    publicCount;
 
   if (indexWarning) {
     sections.push(indexWarning);