claude-memory-layer 1.0.7 → 1.0.9

package/src/server/api/sessions.ts

@@ -4,7 +4,7 @@
  */
 
 import { Hono } from 'hono';
-import { getDefaultMemoryService } from '../../services/memory-service.js';
+import { getReadOnlyMemoryService } from '../../services/memory-service.js';
 
 export const sessionsRouter = new Hono();
 
@@ -12,9 +12,9 @@ export const sessionsRouter = new Hono();
 sessionsRouter.get('/', async (c) => {
   const page = parseInt(c.req.query('page') || '1', 10);
   const pageSize = parseInt(c.req.query('pageSize') || '20', 10);
+  const memoryService = getReadOnlyMemoryService();
 
   try {
-    const memoryService = getDefaultMemoryService();
     await memoryService.initialize();
 
     // Get recent events and extract sessions
@@ -65,15 +65,17 @@ sessionsRouter.get('/', async (c) => {
     });
   } catch (error) {
     return c.json({ error: (error as Error).message }, 500);
+  } finally {
+    await memoryService.shutdown();
   }
 });
 
 // GET /api/sessions/:id - Get session details
 sessionsRouter.get('/:id', async (c) => {
   const { id } = c.req.param();
+  const memoryService = getReadOnlyMemoryService();
 
   try {
-    const memoryService = getDefaultMemoryService();
     await memoryService.initialize();
 
     const events = await memoryService.getSessionHistory(id);
@@ -107,5 +109,7 @@ sessionsRouter.get('/:id', async (c) => {
     });
   } catch (error) {
     return c.json({ error: (error as Error).message }, 500);
+  } finally {
+    await memoryService.shutdown();
   }
 });

package/src/server/api/stats.ts

@@ -4,18 +4,16 @@
  */
 
 import { Hono } from 'hono';
-import { getDefaultMemoryService, getMemoryServiceForProject } from '../../services/memory-service.js';
+import { getReadOnlyMemoryService, getMemoryServiceForProject } from '../../services/memory-service.js';
 
 export const statsRouter = new Hono();
 
 // GET /api/stats/shared - Get shared store statistics
 statsRouter.get('/shared', async (c) => {
+  const memoryService = getReadOnlyMemoryService();
   try {
-    const memoryService = getDefaultMemoryService();
     await memoryService.initialize();
-
     const sharedStats = await memoryService.getSharedStoreStats();
-
     return c.json({
       troubleshooting: sharedStats?.troubleshooting || 0,
       bestPractices: sharedStats?.bestPractices || 0,
@@ -31,18 +29,18 @@ statsRouter.get('/shared', async (c) => {
       totalUsageCount: 0,
       lastUpdated: null
     });
+  } finally {
+    await memoryService.shutdown();
   }
 });
 
 // GET /api/stats/endless - Get endless mode status
 statsRouter.get('/endless', async (c) => {
+  const projectPath = c.req.query('project') || process.cwd();
+  const memoryService = getMemoryServiceForProject(projectPath);
   try {
-    const projectPath = c.req.query('project') || process.cwd();
-    const memoryService = getMemoryServiceForProject(projectPath);
     await memoryService.initialize();
-
     const status = await memoryService.getEndlessModeStatus();
-
     return c.json({
       mode: status.mode,
       continuityScore: status.continuityScore,
@@ -58,15 +56,84 @@ statsRouter.get('/endless', async (c) => {
       consolidatedCount: 0,
       lastConsolidation: null
     });
+  } finally {
+    await memoryService.shutdown();
+  }
+});
+
+// GET /api/stats/levels/:level - Get events by memory level
+statsRouter.get('/levels/:level', async (c) => {
+  const { level } = c.req.param();
+  const limit = parseInt(c.req.query('limit') || '20', 10);
+  const offset = parseInt(c.req.query('offset') || '0', 10);
+  const sort = c.req.query('sort') || 'recent';
+
+  // Validate level
+  const validLevels = ['L0', 'L1', 'L2', 'L3', 'L4'];
+  if (!validLevels.includes(level)) {
+    return c.json({ error: `Invalid level. Must be one of: ${validLevels.join(', ')}` }, 400);
+  }
+
+  const memoryService = getReadOnlyMemoryService();
+  try {
+    await memoryService.initialize();
+    let events = await memoryService.getEventsByLevel(level, { limit: limit * 2, offset });
+    const stats = await memoryService.getStats();
+    const levelStat = stats.levelStats.find(s => s.level === level);
+
+    // Apply sorting
+    if (sort === 'accessed') {
+      // Sort by access count (will need to get from SQLite)
+      // For now, add access count from SQLite if available
+      const sqliteStore = (memoryService as any).sqliteEventStore;
+      if (sqliteStore) {
+        const eventIds = events.map(e => e.id);
+        const accessedEvents = await sqliteStore.getMostAccessed(1000);
+        const accessMap = new Map(accessedEvents.map((e: any) => [e.id, e.access_count || 0]));
+        events = events.map((e: any) => ({
+          ...e,
+          accessCount: accessMap.get(e.id) || 0
+        }));
+        events.sort((a: any, b: any) => b.accessCount - a.accessCount);
+      }
+    } else if (sort === 'oldest') {
+      events.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    } else {
+      // 'recent' - default sorting (newest first)
+      events.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+    }
+
+    // Apply limit after sorting
+    events = events.slice(0, limit);
+
+    return c.json({
+      level,
+      events: events.map((e: any) => ({
+        id: e.id,
+        eventType: e.eventType,
+        sessionId: e.sessionId,
+        timestamp: e.timestamp.toISOString(),
+        content: e.content.slice(0, 500) + (e.content.length > 500 ? '...' : ''),
+        metadata: e.metadata,
+        accessCount: e.accessCount || 0
+      })),
+      total: levelStat?.count || 0,
+      limit,
+      offset,
+      hasMore: events.length === limit
+    });
+  } catch (error) {
+    return c.json({ error: (error as Error).message }, 500);
+  } finally {
+    await memoryService.shutdown();
   }
 });
 
 // GET /api/stats - Get overall statistics
 statsRouter.get('/', async (c) => {
+  const memoryService = getReadOnlyMemoryService();
   try {
-    const memoryService = getDefaultMemoryService();
     await memoryService.initialize();
-
     const stats = await memoryService.getStats();
     const recentEvents = await memoryService.getRecentEvents(10000);
 
@@ -111,17 +178,54 @@ statsRouter.get('/', async (c) => {
     });
   } catch (error) {
     return c.json({ error: (error as Error).message }, 500);
+  } finally {
+    await memoryService.shutdown();
+  }
+});
+
+// GET /api/stats/most-accessed - Get most accessed memories
+statsRouter.get('/most-accessed', async (c) => {
+  const limit = parseInt(c.req.query('limit') || '10', 10);
+  // Use the same read-only service that other stats endpoints use
+  const memoryService = getReadOnlyMemoryService();
+
+  try {
+    await memoryService.initialize();
+    console.log('[most-accessed] Fetching most accessed memories, limit:', limit);
+    const memories = await memoryService.getMostAccessedMemories(limit);
+    console.log('[most-accessed] Got memories:', memories.length);
+
+    return c.json({
+      memories: memories.map(m => ({
+        memoryId: m.memoryId,
+        summary: m.summary,
+        topics: m.topics,
+        accessCount: m.accessCount,
+        lastAccessed: m.lastAccessed || null,
+        confidence: m.confidence,
+        createdAt: m.createdAt instanceof Date ? m.createdAt.toISOString() : m.createdAt
+      })),
+      total: memories.length
+    });
+  } catch (error) {
+    console.error('[most-accessed] Error:', error);
+    return c.json({
+      memories: [],
+      total: 0,
+      error: (error as Error).message
+    });
+  } finally {
+    await memoryService.shutdown();
   }
 });
 
 // GET /api/stats/timeline - Get activity timeline
 statsRouter.get('/timeline', async (c) => {
   const days = parseInt(c.req.query('days') || '7', 10);
+  const memoryService = getReadOnlyMemoryService();
 
   try {
-    const memoryService = getDefaultMemoryService();
     await memoryService.initialize();
-
     const recentEvents = await memoryService.getRecentEvents(10000);
 
     const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
@@ -146,5 +250,48 @@ statsRouter.get('/timeline', async (c) => {
     });
   } catch (error) {
     return c.json({ error: (error as Error).message }, 500);
+  } finally {
+    await memoryService.shutdown();
   }
 });
+
+// POST /api/stats/graduation/run - Force graduation evaluation
+statsRouter.post('/graduation/run', async (c) => {
+  const memoryService = getReadOnlyMemoryService();
+  try {
+    await memoryService.initialize();
+    const result = await memoryService.forceGraduation();
+
+    return c.json({
+      success: true,
+      evaluated: result.evaluated,
+      graduated: result.graduated,
+      byLevel: result.byLevel
+    });
+  } catch (error) {
+    return c.json({
+      success: false,
+      error: (error as Error).message
+    }, 500);
+  } finally {
+    await memoryService.shutdown();
+  }
+});
+
+// GET /api/stats/graduation - Get graduation criteria info
+statsRouter.get('/graduation', async (c) => {
+  return c.json({
+    criteria: {
+      L0toL1: { minAccessCount: 1, minConfidence: 0.5, minCrossSessionRefs: 0, maxAgeDays: 30 },
+      L1toL2: { minAccessCount: 3, minConfidence: 0.7, minCrossSessionRefs: 1, maxAgeDays: 60 },
+      L2toL3: { minAccessCount: 5, minConfidence: 0.85, minCrossSessionRefs: 2, maxAgeDays: 90 },
+      L3toL4: { minAccessCount: 10, minConfidence: 0.92, minCrossSessionRefs: 3, maxAgeDays: 180 }
+    },
+    description: {
+      accessCount: 'Number of times the memory was retrieved/referenced',
+      confidence: 'Match confidence score when retrieved (0.0-1.0)',
+      crossSessionRefs: 'Number of different sessions that referenced this memory',
+      maxAgeDays: 'Maximum days since last access (prevents stale promotion)'
+    }
+  });
+});

package/src/server/index.ts

@@ -3,12 +3,18 @@
  * Provides REST API and serves static UI files
  */
 
+// These are injected by the esbuild banner
+declare const __dirname: string;
+declare const __filename: string;
+
 import { Hono } from 'hono';
 import { cors } from 'hono/cors';
 import { logger } from 'hono/logger';
-import { serveStatic } from 'hono/bun';
+import { serve } from '@hono/node-server';
+import { serveStatic } from '@hono/node-server/serve-static';
 import * as path from 'path';
 import * as fs from 'fs';
+import type { Server } from 'http';
 
 import { apiRouter } from './api/index.js';
 
@@ -25,7 +31,7 @@ app.route('/api', apiRouter);
 app.get('/health', (c) => c.json({ status: 'ok', timestamp: new Date().toISOString() }));
 
 // Static files (UI)
-const uiPath = path.join(import.meta.dir, '../../dist/ui');
+const uiPath = path.join(__dirname, '../../dist/ui');
 if (fs.existsSync(uiPath)) {
   app.use('/*', serveStatic({ root: uiPath }));
 }
@@ -41,20 +47,20 @@ app.get('*', (c) => {
 
 export { app };
 
-let serverInstance: ReturnType<typeof Bun.serve> | null = null;
+let serverInstance: Server | null = null;
 
 /**
  * Start the HTTP server
  */
-export function startServer(port: number = 37777): ReturnType<typeof Bun.serve> {
+export function startServer(port: number = 37777): Server {
   if (serverInstance) {
     return serverInstance;
   }
 
-  serverInstance = Bun.serve({
-    hostname: '127.0.0.1',
+  serverInstance = serve({
+    fetch: app.fetch,
     port,
-    fetch: app.fetch
+    hostname: '127.0.0.1'
   });
 
   console.log(`🧠 Code Memory viewer started at http://localhost:${port}`);
@@ -67,7 +73,7 @@ export function startServer(port: number = 37777): ReturnType<typeof Bun.serve>
  */
 export function stopServer(): void {
   if (serverInstance) {
-    serverInstance.stop();
+    serverInstance.close();
     serverInstance = null;
   }
 }
@@ -85,7 +91,10 @@ export async function isServerRunning(port: number = 37777): Promise<boolean> {
 }
 
 // Start server if run directly
-if (import.meta.main) {
+// Check if this file is being run directly (not imported)
+const isMainModule = process.argv[1]?.includes('server/index') ||
+                     process.argv[1]?.endsWith('server.js');
+if (isMainModule) {
   const port = parseInt(process.env.PORT || '37777', 10);
   startServer(port);
 }