claude-memory-layer 1.0.30 → 1.0.32

package/src/apps/index.ts

@@ -1,5 +0,0 @@
-/**
- * User-facing application entrypoints live here.
- */
-
-export {};

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

@@ -1,244 +0,0 @@
-/**
- * Chat API
- * Endpoints for memory-aware chat using Claude CLI
- */
-
-import { Hono } from 'hono';
-import { streamSSE } from 'hono/streaming';
-import { spawn } from 'child_process';
-import type { ChildProcess } from 'child_process';
-import { getServiceFromQuery } from './utils.js';
-
-export const chatRouter = new Hono();
-
-interface ChatRequest {
-  message: string;
-  history?: Array<{ role: 'user' | 'assistant'; content: string }>;
-}
-
-const CLAUDE_TIMEOUT_MS = 120_000;
-
-chatRouter.post('/', async (c) => {
-  let body: ChatRequest;
-  try {
-    body = await c.req.json<ChatRequest>();
-  } catch {
-    return c.json({ error: 'Invalid JSON body' }, 400);
-  }
-
-  if (!body.message?.trim()) {
-    return c.json({ error: 'Message is required' }, 400);
-  }
-
-  const memoryService = getServiceFromQuery(c);
-
-  try {
-    await memoryService.initialize();
-
-    // Retrieve relevant memories for context
-    let memoryContext = '';
-    let statsContext = '';
-
-    try {
-      const result = await memoryService.retrieveMemories(body.message, {
-        topK: 8,
-        minScore: 0.5
-      });
-
-      if (result.memories.length > 0) {
-        const parts: string[] = ['## Relevant Memories\n'];
-        for (const m of result.memories) {
-          const date = new Date(m.event.timestamp).toISOString().split('T')[0];
-          const content = m.event.content.slice(0, 500);
-          parts.push(`### [${m.event.eventType}] ${date} (score: ${m.score.toFixed(2)})`);
-          parts.push(content);
-          if (m.sessionContext) {
-            parts.push(`_Context: ${m.sessionContext}_`);
-          }
-          parts.push('');
-        }
-        memoryContext = parts.join('\n');
-      }
-    } catch {
-      // Continue without memory context if retrieval fails
-    }
-
-    try {
-      const stats = await memoryService.getStats();
-      const levels = stats.levelStats.map(l => `${l.level}: ${l.count}`).join(', ');
-      statsContext = [
-        '## Memory Stats',
-        `- Total events: ${stats.totalEvents}`,
-        `- Vector nodes: ${stats.vectorCount}`,
-        `- By level: ${levels}`
-      ].join('\n');
-    } catch {
-      // Continue without stats if it fails
-    }
-
-    const fullPrompt = buildPrompt(
-      statsContext,
-      memoryContext,
-      body.history || [],
-      body.message
-    );
-
-    // Stream response via SSE
-    return streamSSE(c, async (stream) => {
-      try {
-        await streamClaudeResponse(fullPrompt, stream);
-      } catch (err) {
-        await stream.writeSSE({
-          event: 'error',
-          data: JSON.stringify({ error: (err as Error).message })
-        });
-      }
-    });
-  } catch (error) {
-    return c.json({ error: (error as Error).message }, 500);
-  } finally {
-    await memoryService.shutdown();
-  }
-});
-
-function buildPrompt(
-  statsContext: string,
-  memoryContext: string,
-  history: Array<{ role: string; content: string }>,
-  currentMessage: string
-): string {
-  const parts: string[] = [];
-
-  parts.push('You are a helpful assistant that answers questions about the user\'s code memory data.');
-  parts.push('The memory system tracks coding sessions, tool usage, prompts, and responses.');
-  parts.push('Answer concisely based on the memory context below. If you don\'t have enough data, say so.');
-  parts.push('Use markdown formatting in your responses.\n');
-
-  if (statsContext) {
-    parts.push(statsContext);
-    parts.push('');
-  }
-
-  if (memoryContext) {
-    parts.push(memoryContext);
-  } else {
-    parts.push('No directly relevant memories found for this query.');
-    parts.push('Answer based on general knowledge or suggest the user rephrase.\n');
-  }
-
-  parts.push('---\n');
-
-  // Include recent history (last 10 turns)
-  const recentHistory = history.slice(-10);
-  if (recentHistory.length > 0) {
-    parts.push('## Conversation History\n');
-    for (const msg of recentHistory) {
-      const prefix = msg.role === 'user' ? 'User' : 'Assistant';
-      parts.push(`**${prefix}:** ${msg.content}\n`);
-    }
-  }
-
-  parts.push(`**User:** ${currentMessage}`);
-
-  return parts.join('\n');
-}
-
-function streamClaudeResponse(
-  prompt: string,
-  stream: { writeSSE: (msg: { event?: string; data: string }) => Promise<void> }
-): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const proc: ChildProcess = spawn('claude', [
-      '-p',
-      '--output-format', 'stream-json',
-      '--verbose'
-    ], {
-      stdio: ['pipe', 'pipe', 'pipe'],
-      env: { ...process.env }
-    });
-
-    const timeout = setTimeout(() => {
-      proc.kill('SIGTERM');
-      reject(new Error('Chat response timed out after 2 minutes'));
-    }, CLAUDE_TIMEOUT_MS);
-
-    // Write prompt to stdin
-    proc.stdin!.write(prompt);
-    proc.stdin!.end();
-
-    let buffer = '';
-    let lastSentText = '';
-
-    proc.stdout!.on('data', async (chunk: Buffer) => {
-      buffer += chunk.toString();
-      const lines = buffer.split('\n');
-      buffer = lines.pop() || '';
-
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        try {
-          const parsed = JSON.parse(line);
-
-          // Extract text from assistant messages
-          if (parsed.type === 'assistant' && parsed.message?.content) {
-            const textBlocks = parsed.message.content
-              .filter((b: { type: string }) => b.type === 'text')
-              .map((b: { text: string }) => b.text)
-              .join('');
-
-            if (textBlocks.length > lastSentText.length) {
-              const delta = textBlocks.slice(lastSentText.length);
-              lastSentText = textBlocks;
-              await stream.writeSSE({
-                event: 'message',
-                data: JSON.stringify({ content: delta })
-              });
-            }
-          }
-
-          // Handle completion
-          if (parsed.type === 'result') {
-            await stream.writeSSE({ event: 'done', data: '{}' });
-          }
-        } catch {
-          // Skip non-JSON lines
-        }
-      }
-    });
-
-    proc.stderr!.on('data', (chunk: Buffer) => {
-      if (process.env.CLAUDE_MEMORY_DEBUG) {
-        console.error('[chat] claude stderr:', chunk.toString());
-      }
-    });
-
-    proc.on('error', (err) => {
-      clearTimeout(timeout);
-      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
-        reject(new Error('Claude CLI not found. Install with: npm install -g @anthropic-ai/claude-code'));
-      } else {
-        reject(err);
-      }
-    });
-
-    proc.on('close', async (code) => {
-      clearTimeout(timeout);
-
-      // Flush remaining buffer
-      if (buffer.trim()) {
-        try {
-          const parsed = JSON.parse(buffer);
-          if (parsed.type === 'result') {
-            await stream.writeSSE({ event: 'done', data: '{}' });
-          }
-        } catch { /* ignore */ }
-      }
-
-      if (code !== 0 && code !== null) {
-        reject(new Error(`Claude CLI exited with code ${code}`));
-      } else {
-        resolve();
-      }
-    });
-  });
-}

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

@@ -1,105 +0,0 @@
-/**
- * Citations API
- * Endpoints for citation management
- */
-
-import { Hono } from 'hono';
-import { getServiceFromQuery } from './utils.js';
-import { generateCitationId, parseCitationId } from '../../../core/citation-generator.js';
-
-export const citationsRouter = new Hono();
-
-// GET /api/citations/:id - Get citation by ID
-citationsRouter.get('/:id', async (c) => {
-  const { id } = c.req.param();
-
-  // Support both formats: "a7Bc3x" or "mem:a7Bc3x"
-  const citationId = parseCitationId(id) || id;
-  const memoryService = getServiceFromQuery(c);
-
-  try {
-    await memoryService.initialize();
-
-    // Search through recent events to find the one matching this citation ID
-    const recentEvents = await memoryService.getRecentEvents(10000);
-
-    const event = recentEvents.find(e => {
-      const eventCitationId = generateCitationId(e.id);
-      return eventCitationId === citationId;
-    });
-
-    if (!event) {
-      return c.json({ error: 'Citation not found' }, 404);
-    }
-
-    return c.json({
-      citation: {
-        id: citationId,
-        eventId: event.id
-      },
-      event: {
-        id: event.id,
-        eventType: event.eventType,
-        timestamp: event.timestamp,
-        sessionId: event.sessionId,
-        content: event.content,
-        metadata: event.metadata
-      }
-    });
-  } catch (error) {
-    return c.json({ error: (error as Error).message }, 500);
-  } finally {
-    await memoryService.shutdown();
-  }
-});
-
-// GET /api/citations/:id/related - Get related citations
-citationsRouter.get('/:id/related', async (c) => {
-  const { id } = c.req.param();
-  const citationId = parseCitationId(id) || id;
-  const memoryService = getServiceFromQuery(c);
-
-  try {
-    await memoryService.initialize();
-
-    const recentEvents = await memoryService.getRecentEvents(10000);
-
-    // Find the main event
-    const event = recentEvents.find(e => {
-      const eventCitationId = generateCitationId(e.id);
-      return eventCitationId === citationId;
-    });
-
-    if (!event) {
-      return c.json({ error: 'Citation not found' }, 404);
-    }
-
-    // Get surrounding events from same session
-    const sessionEvents = recentEvents
-      .filter(e => e.sessionId === event.sessionId)
-      .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-
-    const eventIndex = sessionEvents.findIndex(e => e.id === event.id);
-    const prev = eventIndex > 0 ? sessionEvents[eventIndex - 1] : null;
-    const next = eventIndex < sessionEvents.length - 1 ? sessionEvents[eventIndex + 1] : null;
-
-    return c.json({
-      previous: prev ? {
-        citationId: generateCitationId(prev.id),
-        eventType: prev.eventType,
-        timestamp: prev.timestamp,
-        preview: prev.content.slice(0, 100) + (prev.content.length > 100 ? '...' : '')
-      } : null,
-      next: next ? {
-        citationId: generateCitationId(next.id),
-        eventType: next.eventType,
-        timestamp: next.timestamp,
-        preview: next.content.slice(0, 100) + (next.content.length > 100 ? '...' : '')
-      } : null
-    });
-  } catch (error) {
-    return c.json({ error: (error as Error).message }, 500);
-  } finally {
-    await memoryService.shutdown();
-  }
-});

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

@@ -1,137 +0,0 @@
-/**
- * Events API
- * Endpoints for event management
- */
-
-import { Hono } from 'hono';
-import { getServiceFromQuery } from './utils.js';
-
-export const eventsRouter = new Hono();
-
-// GET /api/events - List events with filters
-eventsRouter.get('/', async (c) => {
-  const sessionId = c.req.query('sessionId');
-  const eventType = c.req.query('type');
-  const level = c.req.query('level');
-  const sort = c.req.query('sort') || 'recent'; // recent | accessed | oldest
-  const q = (c.req.query('q') || '').trim().toLowerCase();
-  const limit = parseInt(c.req.query('limit') || '100', 10);
-  const offset = parseInt(c.req.query('offset') || '0', 10);
-  const memoryService = getServiceFromQuery(c);
-
-  try {
-    await memoryService.initialize();
-
-    let events: any[];
-
-    // Filter by level using the dedicated method
-    if (level) {
-      events = await memoryService.getEventsByLevel(level, { limit: limit + offset + 1000, offset: 0 });
-    } else {
-      events = await memoryService.getRecentEvents(limit + offset + 1000);
-    }
-
-    // Filter by session
-    if (sessionId) {
-      events = events.filter(e => e.sessionId === sessionId);
-    }
-
-    // Filter by type
-    if (eventType) {
-      events = events.filter(e => e.eventType === eventType);
-    }
-
-    // Content query filter
-    if (q) {
-      events = events.filter(e => (e.content || '').toLowerCase().includes(q));
-    }
-
-    // Sort
-    if (sort === 'accessed') {
-      events.sort((a: any, b: any) => {
-        const aTime = a.last_accessed_at || '';
-        const bTime = b.last_accessed_at || '';
-        return bTime.localeCompare(aTime);
-      });
-    } else if (sort === 'most-accessed') {
-      events.sort((a: any, b: any) => (b.access_count || 0) - (a.access_count || 0));
-    } else if (sort === 'oldest') {
-      events.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-    }
-    // 'recent' is default (already sorted by timestamp DESC from the query)
-
-    // Pagination
-    const total = events.length;
-    events = events.slice(offset, offset + limit);
-
-    return c.json({
-      events: events.map(e => ({
-        id: e.id,
-        eventType: e.eventType,
-        timestamp: e.timestamp,
-        sessionId: e.sessionId,
-        preview: e.content.slice(0, 200) + (e.content.length > 200 ? '...' : ''),
-        contentLength: e.content.length,
-        metadata: e.metadata,
-        accessCount: (e as any).access_count || 0,
-        lastAccessedAt: (e as any).last_accessed_at || null
-      })),
-      total,
-      limit,
-      offset,
-      hasMore: offset + limit < total
-    });
-  } catch (error) {
-    return c.json({ error: (error as Error).message }, 500);
-  } finally {
-    await memoryService.shutdown();
-  }
-});
-
-// GET /api/events/:id - Get event details
-eventsRouter.get('/:id', async (c) => {
-  const { id } = c.req.param();
-  const memoryService = getServiceFromQuery(c);
-
-  try {
-    await memoryService.initialize();
-
-    const recentEvents = await memoryService.getRecentEvents(10000);
-    const event = recentEvents.find(e => e.id === id);
-
-    if (!event) {
-      return c.json({ error: 'Event not found' }, 404);
-    }
-
-    // Get surrounding events for context
-    const sessionEvents = recentEvents
-      .filter(e => e.sessionId === event.sessionId)
-      .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-
-    const eventIndex = sessionEvents.findIndex(e => e.id === id);
-    const start = Math.max(0, eventIndex - 2);
-    const end = Math.min(sessionEvents.length, eventIndex + 3);
-    const context = sessionEvents.slice(start, end).filter(e => e.id !== id);
-
-    return c.json({
-      event: {
-        id: event.id,
-        eventType: event.eventType,
-        timestamp: event.timestamp,
-        sessionId: event.sessionId,
-        content: event.content,
-        metadata: event.metadata
-      },
-      context: context.map(e => ({
-        id: e.id,
-        eventType: e.eventType,
-        timestamp: e.timestamp,
-        preview: e.content.slice(0, 100) + (e.content.length > 100 ? '...' : '')
-      }))
-    });
-  } catch (error) {
-    return c.json({ error: (error as Error).message }, 500);
-  } finally {
-    await memoryService.shutdown();
-  }
-});

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

@@ -1,53 +0,0 @@
-/**
- * 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

@@ -1,26 +0,0 @@
-/**
- * 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

@@ -1,74 +0,0 @@
-/**
- * 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];
-}