claude-memory-layer 1.0.27 → 1.0.28

package/src/apps/server/api/health.ts

@@ -0,0 +1,53 @@
+/**
+ * Health API
+ * Operational health checks including outbox backlog/failures
+ */
+
+import { Hono } from 'hono';
+import { getServiceFromQuery } from './utils.js';
+
+export const healthRouter = new Hono();
+
+// GET /api/health
+healthRouter.get('/', async (c) => {
+  const memoryService = getServiceFromQuery(c);
+  try {
+    await memoryService.initialize();
+
+    const [stats, outbox] = await Promise.all([
+      memoryService.getStats(),
+      memoryService.getOutboxStats()
+    ]);
+
+    const outboxPending = outbox.embedding.pending + outbox.vector.pending;
+    const outboxFailed = outbox.embedding.failed + outbox.vector.failed;
+
+    const status = outboxFailed > 0 ? 'needs-attention' : 'ok';
+
+    return c.json({
+      status,
+      timestamp: new Date().toISOString(),
+      storage: {
+        totalEvents: stats.totalEvents,
+        vectorCount: stats.vectorCount
+      },
+      outbox: {
+        embedding: outbox.embedding,
+        vector: outbox.vector,
+        totals: {
+          pending: outboxPending,
+          failed: outboxFailed
+        }
+      },
+      levelStats: stats.levelStats
+    });
+  } catch (error) {
+    return c.json({
+      status: 'error',
+      timestamp: new Date().toISOString(),
+      error: (error as Error).message
+    }, 500);
+  } finally {
+    await memoryService.shutdown();
+  }
+});

package/src/apps/server/api/index.ts

@@ -0,0 +1,26 @@
+/**
+ * API Router
+ * Central router for all API endpoints
+ */
+
+import { Hono } from 'hono';
+import { sessionsRouter } from './sessions.js';
+import { eventsRouter } from './events.js';
+import { searchRouter } from './search.js';
+import { statsRouter } from './stats.js';
+import { citationsRouter } from './citations.js';
+import { turnsRouter } from './turns.js';
+import { projectsRouter } from './projects.js';
+import { chatRouter } from './chat.js';
+import { healthRouter } from './health.js';
+
+export const apiRouter = new Hono()
+  .route('/sessions', sessionsRouter)
+  .route('/events', eventsRouter)
+  .route('/search', searchRouter)
+  .route('/stats', statsRouter)
+  .route('/citations', citationsRouter)
+  .route('/turns', turnsRouter)
+  .route('/projects', projectsRouter)
+  .route('/chat', chatRouter)
+  .route('/health', healthRouter);

package/src/apps/server/api/projects.ts

@@ -0,0 +1,74 @@
+/**
+ * Projects API
+ * Endpoints for listing available projects
+ */
+
+import { Hono } from 'hono';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { loadSessionRegistry } from '../../../services/memory-service.js';
+
+export const projectsRouter = new Hono();
+
+// GET /api/projects - List available projects
+projectsRouter.get('/', async (c) => {
+  try {
+    const projectsDir = path.join(os.homedir(), '.claude-code', 'memory', 'projects');
+
+    if (!fs.existsSync(projectsDir)) {
+      return c.json({ projects: [] });
+    }
+
+    // Read project directories
+    const projectHashes = fs.readdirSync(projectsDir)
+      .filter(name => {
+        const fullPath = path.join(projectsDir, name);
+        return fs.statSync(fullPath).isDirectory();
+      });
+
+    // Load session registry to map hashes to project paths
+    const registry = loadSessionRegistry();
+    const hashToPath = new Map<string, string>();
+    for (const entry of Object.values(registry.sessions)) {
+      if (!hashToPath.has(entry.projectHash)) {
+        hashToPath.set(entry.projectHash, entry.projectPath);
+      }
+    }
+
+    // Build project list
+    const projects = projectHashes.map(hash => {
+      const dirPath = path.join(projectsDir, hash);
+      const dbPath = path.join(dirPath, 'events.sqlite');
+      let dbSize = 0;
+      if (fs.existsSync(dbPath)) {
+        dbSize = fs.statSync(dbPath).size;
+      }
+
+      const projectPath = hashToPath.get(hash) || `unknown (${hash})`;
+
+      return {
+        hash,
+        projectPath,
+        projectName: path.basename(projectPath),
+        dbSize,
+        dbSizeHuman: formatBytes(dbSize)
+      };
+    });
+
+    // Sort by project name
+    projects.sort((a, b) => a.projectName.localeCompare(b.projectName));
+
+    return c.json({ projects });
+  } catch (error) {
+    return c.json({ projects: [], error: (error as Error).message }, 500);
+  }
+});
+
+function formatBytes(bytes: number): string {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
+}

package/src/apps/server/api/search.ts

@@ -0,0 +1,184 @@
+/**
+ * Search API
+ * Endpoints for memory search
+ */
+
+import { Hono } from 'hono';
+import { getLightweightServiceFromQuery, getServiceFromQuery } from './utils.js';
+
+export const searchRouter = new Hono();
+
+interface SearchRequest {
+  query: string;
+  options?: {
+    topK?: number;
+    minScore?: number;
+    sessionId?: string;
+    eventType?: string;
+  };
+}
+
+interface DisclosureSearchRequest {
+  query: string;
+  options?: {
+    topK?: number;
+    minScore?: number;
+    sessionId?: string;
+    includeShared?: boolean;
+    adaptiveRerank?: boolean;
+    intentRewrite?: boolean;
+    projectScopeMode?: 'strict' | 'prefer' | 'global';
+    allowedProjectHashes?: string[];
+    strategy?: 'auto' | 'fast' | 'deep';
+  };
+}
+
+// POST /api/search - Search memories
+searchRouter.post('/', async (c) => {
+  const memoryService = getServiceFromQuery(c);
+  try {
+    const body = await c.req.json<SearchRequest>();
+
+    if (!body.query) {
+      return c.json({ error: 'Query is required' }, 400);
+    }
+
+    await memoryService.initialize();
+
+    const startTime = Date.now();
+
+    const result = await memoryService.retrieveMemories(body.query, {
+      topK: body.options?.topK ?? 10,
+      minScore: body.options?.minScore ?? 0.7,
+      sessionId: body.options?.sessionId
+    });
+
+    const searchTime = Date.now() - startTime;
+
+    return c.json({
+      results: result.memories.map(m => ({
+        id: m.event.id,
+        eventType: m.event.eventType,
+        timestamp: m.event.timestamp,
+        sessionId: m.event.sessionId,
+        score: m.score,
+        content: m.event.content,
+        preview: m.event.content.slice(0, 200) + (m.event.content.length > 200 ? '...' : ''),
+        context: m.sessionContext
+      })),
+      meta: {
+        totalMatches: result.memories.length,
+        searchTime,
+        confidence: result.matchResult.confidence,
+        totalTokens: result.totalTokens
+      }
+    });
+  } catch (error) {
+    return c.json({ error: (error as Error).message }, 500);
+  } finally {
+    await memoryService.shutdown();
+  }
+});
+
+// POST /api/search/disclosure - Progressive disclosure search (Search layer)
+searchRouter.post('/disclosure', async (c) => {
+  let memoryService: ReturnType<typeof getServiceFromQuery> | undefined;
+  try {
+    const body = await c.req.json<DisclosureSearchRequest>();
+
+    if (!body.query) {
+      return c.json({ error: 'Query is required' }, 400);
+    }
+
+    memoryService = body.options?.strategy === 'fast'
+      ? getLightweightServiceFromQuery(c)
+      : getServiceFromQuery(c);
+
+    await memoryService.initialize();
+    const result = await memoryService.searchDisclosure(body.query, body.options);
+    return c.json(result);
+  } catch (error) {
+    return c.json({ error: (error as Error).message }, 500);
+  } finally {
+    await memoryService?.shutdown();
+  }
+});
+
+// GET /api/search/disclosure/:resultId/expand - Expand a disclosure search result
+searchRouter.get('/disclosure/:resultId/expand', async (c) => {
+  const memoryService = getServiceFromQuery(c);
+  try {
+    const resultId = c.req.param('resultId');
+    const rawWindowSize = c.req.query('windowSize');
+    const windowSize = rawWindowSize ? parseInt(rawWindowSize, 10) : undefined;
+    const result = await memoryService.expandDisclosure(
+      resultId,
+      Number.isFinite(windowSize) ? { windowSize } : undefined
+    );
+
+    if (!result) {
+      return c.json({ error: 'Expansion target not found' }, 404);
+    }
+
+    return c.json(result);
+  } catch (error) {
+    return c.json({ error: (error as Error).message }, 500);
+  } finally {
+    await memoryService.shutdown();
+  }
+});
+
+// GET /api/search/disclosure/:resultId/source - Resolve source for a disclosure search result
+searchRouter.get('/disclosure/:resultId/source', async (c) => {
+  const memoryService = getServiceFromQuery(c);
+  try {
+    const resultId = c.req.param('resultId');
+    const result = await memoryService.sourceDisclosure(resultId);
+
+    if (!result) {
+      return c.json({ error: 'Source not found' }, 404);
+    }
+
+    return c.json(result);
+  } catch (error) {
+    return c.json({ error: (error as Error).message }, 500);
+  } finally {
+    await memoryService.shutdown();
+  }
+});
+
+// GET /api/search - Simple search via query param
+searchRouter.get('/', async (c) => {
+  const query = c.req.query('q');
+
+  if (!query) {
+    return c.json({ error: 'Query parameter "q" is required' }, 400);
+  }
+
+  const topK = parseInt(c.req.query('topK') || '5', 10);
+  const memoryService = getServiceFromQuery(c);
+
+  try {
+    await memoryService.initialize();
+
+    const result = await memoryService.retrieveMemories(query, { topK });
+
+    return c.json({
+      results: result.memories.map(m => ({
+        id: m.event.id,
+        eventType: m.event.eventType,
+        timestamp: m.event.timestamp,
+        score: m.score,
+        preview: m.event.content.slice(0, 200) + (m.event.content.length > 200 ? '...' : '')
+      })),
+      meta: {
+        totalMatches: result.memories.length,
+        confidence: result.matchResult.confidence
+      }
+    });
+  } catch (error) {
+    return c.json({ error: (error as Error).message }, 500);
+  } finally {
+    await memoryService.shutdown();
+  }
+});

package/src/apps/server/api/sessions.ts

@@ -0,0 +1,115 @@
+/**
+ * Sessions API
+ * Endpoints for session management
+ */
+
+import { Hono } from 'hono';
+import { getServiceFromQuery } from './utils.js';
+
+export const sessionsRouter = new Hono();
+
+// GET /api/sessions - List all sessions
+sessionsRouter.get('/', async (c) => {
+  const page = parseInt(c.req.query('page') || '1', 10);
+  const pageSize = parseInt(c.req.query('pageSize') || '20', 10);
+  const memoryService = getServiceFromQuery(c);
+
+  try {
+    await memoryService.initialize();
+
+    // Get recent events and extract sessions
+    const recentEvents = await memoryService.getRecentEvents(1000);
+
+    // Group by session
+    const sessionMap = new Map<string, {
+      id: string;
+      startedAt: Date;
+      eventCount: number;
+      lastEventAt: Date;
+    }>();
+
+    for (const event of recentEvents) {
+      const existing = sessionMap.get(event.sessionId);
+      if (!existing) {
+        sessionMap.set(event.sessionId, {
+          id: event.sessionId,
+          startedAt: event.timestamp,
+          eventCount: 1,
+          lastEventAt: event.timestamp
+        });
+      } else {
+        existing.eventCount++;
+        if (event.timestamp < existing.startedAt) {
+          existing.startedAt = event.timestamp;
+        }
+        if (event.timestamp > existing.lastEventAt) {
+          existing.lastEventAt = event.timestamp;
+        }
+      }
+    }
+
+    const sessions = Array.from(sessionMap.values())
+      .sort((a, b) => b.lastEventAt.getTime() - a.lastEventAt.getTime());
+
+    const total = sessions.length;
+    const start = (page - 1) * pageSize;
+    const end = start + pageSize;
+    const paginatedSessions = sessions.slice(start, end);
+
+    return c.json({
+      sessions: paginatedSessions,
+      total,
+      page,
+      pageSize,
+      hasMore: end < total
+    });
+  } 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 = getServiceFromQuery(c);
+
+  try {
+    await memoryService.initialize();
+
+    const events = await memoryService.getSessionHistory(id);
+
+    if (events.length === 0) {
+      return c.json({ error: 'Session not found' }, 404);
+    }
+
+    const session = {
+      id,
+      startedAt: events[0].timestamp,
+      endedAt: events[events.length - 1].timestamp,
+      eventCount: events.length
+    };
+
+    const eventsByType = {
+      user_prompt: events.filter(e => e.eventType === 'user_prompt').length,
+      agent_response: events.filter(e => e.eventType === 'agent_response').length,
+      tool_observation: events.filter(e => e.eventType === 'tool_observation').length
+    };
+
+    return c.json({
+      session,
+      events: events.slice(0, 100).map(e => ({
+        id: e.id,
+        eventType: e.eventType,
+        timestamp: e.timestamp,
+        preview: e.content.slice(0, 200) + (e.content.length > 200 ? '...' : '')
+      })),
+      stats: eventsByType
+    });
+  } catch (error) {
+    return c.json({ error: (error as Error).message }, 500);
+  } finally {
+    await memoryService.shutdown();
+  }
+});