claude-memory-layer 1.0.26 → 1.0.28

package/src/{ui → apps/dashboard}/style.css

@@ -1526,3 +1526,225 @@ body {
 @media (max-width: 768px) {
   .chat-panel { width: 100%; }
 }
+
+/* Progressive Retrieval Disclosure */
+.disclosure-card {
+  margin-top: 24px;
+}
+
+.disclosure-controls,
+.disclosure-search-row,
+.disclosure-layout,
+.disclosure-result-head,
+.disclosure-reasons,
+.disclosure-context-item {
+  display: flex;
+  gap: 8px;
+  align-items: center;
+}
+
+.disclosure-controls {
+  flex-wrap: wrap;
+  justify-content: flex-end;
+}
+
+.disclosure-toggle {
+  font-size: 12px;
+  color: var(--text-muted);
+  display: inline-flex;
+  gap: 6px;
+  align-items: center;
+}
+
+.project-dropdown.compact {
+  width: 92px;
+  padding: 7px 10px;
+  font-size: 12px;
+}
+
+.search-input.compact {
+  width: 70px;
+  padding-left: 10px;
+}
+
+.disclosure-search-row {
+  align-items: stretch;
+  margin-bottom: 8px;
+}
+
+.disclosure-search-wrapper {
+  flex: 1;
+}
+
+.disclosure-status {
+  min-height: 18px;
+  font-size: 12px;
+  color: var(--text-muted);
+  margin-bottom: 10px;
+}
+
+.disclosure-layout {
+  align-items: stretch;
+  gap: 12px;
+}
+
+.disclosure-results,
+.disclosure-drilldown {
+  flex: 1;
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.disclosure-drilldown {
+  background: rgba(0, 0, 0, 0.14);
+  border: 1px solid rgba(255, 255, 255, 0.06);
+  border-radius: 12px;
+  padding: 12px;
+}
+
+.disclosure-empty {
+  color: var(--text-muted);
+  font-size: 13px;
+  text-align: center;
+  padding: 18px;
+}
+
+.disclosure-empty.compact {
+  text-align: left;
+  padding: 6px 0;
+}
+
+.disclosure-meta {
+  font-size: 11px;
+  color: var(--text-muted);
+  padding: 0 2px 4px;
+}
+
+.disclosure-result {
+  width: 100%;
+  text-align: left;
+  border: 1px solid rgba(255, 255, 255, 0.06);
+  background: rgba(255, 255, 255, 0.025);
+  border-radius: 12px;
+  color: var(--text-secondary);
+  padding: 10px;
+  cursor: pointer;
+  transition: all 0.18s ease;
+}
+
+.disclosure-result:hover,
+.disclosure-result.active {
+  border-color: var(--accent-primary);
+  background: rgba(123, 97, 255, 0.10);
+}
+
+.disclosure-result-head {
+  justify-content: space-between;
+  margin-bottom: 6px;
+}
+
+.disclosure-score {
+  font-size: 11px;
+  color: var(--text-muted);
+}
+
+.disclosure-title {
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--text-primary);
+  margin-bottom: 4px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.disclosure-snippet {
+  font-size: 12px;
+  color: var(--text-secondary);
+  display: -webkit-box;
+  -webkit-line-clamp: 2;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
+  margin-bottom: 8px;
+}
+
+.disclosure-reasons {
+  flex-wrap: wrap;
+}
+
+.disclosure-source-ref {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  margin-bottom: 6px;
+}
+
+.disclosure-provenance {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
+  gap: 5px 8px;
+  margin: 7px 0 9px;
+  padding: 8px;
+  border: 1px solid rgba(0, 240, 255, 0.12);
+  border-radius: 10px;
+  background: rgba(0, 240, 255, 0.035);
+}
+
+.disclosure-provenance-row {
+  min-width: 0;
+}
+
+.disclosure-provenance-key {
+  display: block;
+  color: var(--text-muted);
+  font-size: 9px;
+  text-transform: uppercase;
+  letter-spacing: 0.4px;
+  margin-bottom: 2px;
+}
+
+.disclosure-provenance-value {
+  display: block;
+  color: var(--text-secondary);
+  font-size: 11px;
+  overflow-wrap: anywhere;
+}
+
+.disclosure-chip {
+  font-size: 10px;
+  color: var(--text-muted);
+  border: 1px solid rgba(255, 255, 255, 0.08);
+  background: rgba(255, 255, 255, 0.035);
+  border-radius: 999px;
+  padding: 3px 7px;
+}
+
+.disclosure-layer + .disclosure-layer {
+  margin-top: 14px;
+}
+
+.disclosure-context-list {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  margin-bottom: 10px;
+}
+
+.disclosure-context-item {
+  align-items: flex-start;
+  font-size: 12px;
+  color: var(--text-secondary);
+  background: rgba(255, 255, 255, 0.025);
+  border-radius: 8px;
+  padding: 7px;
+}
+
+@media (max-width: 1100px) {
+  .disclosure-layout,
+  .disclosure-search-row {
+    flex-direction: column;
+  }
+}
+

package/src/apps/index.ts

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

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

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

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

@@ -0,0 +1,137 @@
+/**
+ * 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();
+  }
+});