claude-memory-layer 1.0.0 → 1.0.1

package/src/hooks/session-start.ts

@@ -4,7 +4,10 @@
  * Called when a new Claude Code session starts
  */
 
-import { getDefaultMemoryService } from '../services/memory-service.js';
+import {
+  getMemoryServiceForProject,
+  registerSession
+} from '../services/memory-service.js';
 import type { SessionStartInput, SessionStartOutput } from '../core/types.js';
 
 async function main(): Promise<void> {
@@ -12,22 +15,23 @@ async function main(): Promise<void> {
   const inputData = await readStdin();
   const input: SessionStartInput = JSON.parse(inputData);
 
-  const memoryService = getDefaultMemoryService();
+  // Register session with project path for other hooks to find
+  registerSession(input.session_id, input.cwd);
+
+  // Get project-specific memory service
+  const memoryService = getMemoryServiceForProject(input.cwd);
 
   try {
     // Start session in memory service
     await memoryService.startSession(input.session_id, input.cwd);
 
-    // Get recent context for this project
+    // Get recent context for this project (now automatically scoped)
     const recentEvents = await memoryService.getRecentEvents(10);
-    const projectEvents = recentEvents.filter(e =>
-      e.metadata?.projectPath === input.cwd
-    );
 
     let context = '';
-    if (projectEvents.length > 0) {
+    if (recentEvents.length > 0) {
       context = `## Previous Session Context\n\nYou have worked on this project before. Here are some relevant memories:\n\n`;
-      for (const event of projectEvents.slice(0, 3)) {
+      for (const event of recentEvents.slice(0, 3)) {
         const date = event.timestamp.toISOString().split('T')[0];
         context += `- **${date}**: ${event.content.slice(0, 150)}...\n`;
       }

package/src/hooks/stop.ts

@@ -4,7 +4,7 @@
  * Called when agent stops - stores the conversation messages
  */
 
-import { getDefaultMemoryService } from '../services/memory-service.js';
+import { getMemoryServiceForSession } from '../services/memory-service.js';
 import { applyPrivacyFilter } from '../core/privacy/index.js';
 import type { StopInput, Config } from '../core/types.js';
 
@@ -25,7 +25,8 @@ async function main(): Promise<void> {
   const inputData = await readStdin();
   const input: StopInput = JSON.parse(inputData);
 
-  const memoryService = getDefaultMemoryService();
+  // Get project-specific memory service via session lookup
+  const memoryService = getMemoryServiceForSession(input.session_id);
 
   try {
     // Store agent responses from the conversation

package/src/hooks/user-prompt-submit.ts

@@ -4,7 +4,7 @@
  * Called when user submits a prompt - retrieves relevant memories
  */
 
-import { getDefaultMemoryService } from '../services/memory-service.js';
+import { getMemoryServiceForSession } from '../services/memory-service.js';
 import type { UserPromptSubmitInput, UserPromptSubmitOutput } from '../core/types.js';
 
 async function main(): Promise<void> {
@@ -12,7 +12,8 @@ async function main(): Promise<void> {
   const inputData = await readStdin();
   const input: UserPromptSubmitInput = JSON.parse(inputData);
 
-  const memoryService = getDefaultMemoryService();
+  // Get project-specific memory service via session lookup
+  const memoryService = getMemoryServiceForSession(input.session_id);
 
   try {
     // Retrieve relevant memories for the prompt

package/src/services/memory-service.ts

@@ -42,6 +42,119 @@ export interface MemoryServiceConfig {
   embeddingModel?: string;
 }
 
+// ============================================================
+// Project Path Utilities
+// ============================================================
+
+/**
+ * Normalize and resolve a project path, handling symlinks
+ */
+function normalizePath(projectPath: string): string {
+  const expanded = projectPath.startsWith('~')
+    ? path.join(os.homedir(), projectPath.slice(1))
+    : projectPath;
+
+  try {
+    // Resolve symlinks for consistent paths
+    return fs.realpathSync(expanded);
+  } catch {
+    // Path doesn't exist yet, just resolve it
+    return path.resolve(expanded);
+  }
+}
+
+/**
+ * Generate a stable 8-character hash from a project path
+ */
+export function hashProjectPath(projectPath: string): string {
+  const normalizedPath = normalizePath(projectPath);
+  return crypto.createHash('sha256')
+    .update(normalizedPath)
+    .digest('hex')
+    .slice(0, 8);
+}
+
+/**
+ * Get the storage path for a specific project
+ */
+export function getProjectStoragePath(projectPath: string): string {
+  const hash = hashProjectPath(projectPath);
+  return path.join(os.homedir(), '.claude-code', 'memory', 'projects', hash);
+}
+
+// ============================================================
+// Session Registry
+// ============================================================
+
+const REGISTRY_PATH = path.join(os.homedir(), '.claude-code', 'memory', 'session-registry.json');
+
+interface SessionRegistryEntry {
+  projectPath: string;
+  projectHash: string;
+  registeredAt: string;
+}
+
+interface SessionRegistry {
+  version: number;
+  sessions: Record<string, SessionRegistryEntry>;
+}
+
+function loadSessionRegistry(): SessionRegistry {
+  try {
+    if (fs.existsSync(REGISTRY_PATH)) {
+      const data = fs.readFileSync(REGISTRY_PATH, 'utf-8');
+      return JSON.parse(data);
+    }
+  } catch (error) {
+    console.error('Failed to load session registry:', error);
+  }
+  return { version: 1, sessions: {} };
+}
+
+function saveSessionRegistry(registry: SessionRegistry): void {
+  const dir = path.dirname(REGISTRY_PATH);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  // Atomic write using temp file
+  const tempPath = REGISTRY_PATH + '.tmp';
+  fs.writeFileSync(tempPath, JSON.stringify(registry, null, 2));
+  fs.renameSync(tempPath, REGISTRY_PATH);
+}
+
+/**
+ * Register a session with its project path
+ */
+export function registerSession(sessionId: string, projectPath: string): void {
+  const registry = loadSessionRegistry();
+
+  registry.sessions[sessionId] = {
+    projectPath: normalizePath(projectPath),
+    projectHash: hashProjectPath(projectPath),
+    registeredAt: new Date().toISOString()
+  };
+
+  // Clean up old sessions (keep last 1000)
+  const entries = Object.entries(registry.sessions);
+  if (entries.length > 1000) {
+    const sorted = entries.sort((a, b) =>
+      new Date(b[1].registeredAt).getTime() - new Date(a[1].registeredAt).getTime()
+    );
+    registry.sessions = Object.fromEntries(sorted.slice(0, 1000));
+  }
+
+  saveSessionRegistry(registry);
+}
+
+/**
+ * Get the project path for a session
+ */
+export function getSessionProject(sessionId: string): SessionRegistryEntry | null {
+  const registry = loadSessionRegistry();
+  return registry.sessions[sessionId] || null;
+}
+
 export class MemoryService {
   private readonly eventStore: EventStore;
   private readonly vectorStore: VectorStore;
@@ -609,16 +722,55 @@ export class MemoryService {
   }
 }
 
-// Default instance
-let defaultService: MemoryService | null = null;
+// ============================================================
+// Service Instance Management
+// ============================================================
+
+// Instance cache: Map from project hash (or '__global__') to MemoryService
+const serviceCache = new Map<string, MemoryService>();
+const GLOBAL_KEY = '__global__';
 
+/**
+ * Get the global memory service (backward compatibility)
+ * Use this for operations not tied to a specific project
+ */
 export function getDefaultMemoryService(): MemoryService {
-  if (!defaultService) {
-    defaultService = new MemoryService({
+  if (!serviceCache.has(GLOBAL_KEY)) {
+    serviceCache.set(GLOBAL_KEY, new MemoryService({
       storagePath: '~/.claude-code/memory'
-    });
+    }));
   }
-  return defaultService;
+  return serviceCache.get(GLOBAL_KEY)!;
+}
+
+/**
+ * Get memory service for a specific project path
+ * Creates isolated storage at ~/.claude-code/memory/projects/{hash}/
+ */
+export function getMemoryServiceForProject(projectPath: string): MemoryService {
+  const hash = hashProjectPath(projectPath);
+
+  if (!serviceCache.has(hash)) {
+    const storagePath = getProjectStoragePath(projectPath);
+    serviceCache.set(hash, new MemoryService({ storagePath }));
+  }
+
+  return serviceCache.get(hash)!;
+}
+
+/**
+ * Get memory service for a session by looking up its project
+ * Falls back to global storage if session not found in registry
+ */
+export function getMemoryServiceForSession(sessionId: string): MemoryService {
+  const projectInfo = getSessionProject(sessionId);
+
+  if (projectInfo) {
+    return getMemoryServiceForProject(projectInfo.projectPath);
+  }
+
+  // Fallback to global storage for unknown sessions (backward compat)
+  return getDefaultMemoryService();
 }
 
 export function createMemoryService(config: MemoryServiceConfig): MemoryService {