claude-memory-layer 1.0.31 → 1.0.33

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

@@ -1,143 +0,0 @@
-/**
- * Turns API
- * Endpoints for viewing events grouped by conversation turn
- *
- * A "turn" groups a user_prompt with its associated tool_observations
- * and the final agent_response into a single logical unit.
- */
-
-import { Hono } from 'hono';
-import { getServiceFromQuery } from './utils.js';
-
-export const turnsRouter = new Hono();
-
-// GET /api/turns?sessionId=xxx - List turns for a session
-turnsRouter.get('/', async (c) => {
-  const sessionId = c.req.query('sessionId');
-  const limit = parseInt(c.req.query('limit') || '20', 10);
-  const offset = parseInt(c.req.query('offset') || '0', 10);
-
-  if (!sessionId) {
-    return c.json({ error: 'sessionId is required' }, 400);
-  }
-
-  const memoryService = getServiceFromQuery(c);
-
-  try {
-    await memoryService.initialize();
-
-    const turns = await memoryService.getSessionTurns(sessionId, { limit, offset });
-    const totalTurns = await memoryService.countSessionTurns(sessionId);
-
-    return c.json({
-      turns: turns.map(t => ({
-        turnId: t.turnId,
-        startedAt: t.startedAt.toISOString(),
-        promptPreview: t.promptPreview,
-        eventCount: t.eventCount,
-        toolCount: t.toolCount,
-        hasResponse: t.hasResponse,
-        events: t.events.map(e => ({
-          id: e.id,
-          eventType: e.eventType,
-          timestamp: e.timestamp instanceof Date ? e.timestamp.toISOString() : e.timestamp,
-          preview: e.content.slice(0, 300) + (e.content.length > 300 ? '...' : ''),
-          contentLength: e.content.length
-        }))
-      })),
-      total: totalTurns,
-      limit,
-      offset,
-      hasMore: offset + limit < totalTurns
-    });
-  } catch (error) {
-    return c.json({ error: (error as Error).message }, 500);
-  } finally {
-    await memoryService.shutdown();
-  }
-});
-
-// GET /api/turns/:turnId - Get full turn details
-turnsRouter.get('/:turnId', async (c) => {
-  const { turnId } = c.req.param();
-  const memoryService = getServiceFromQuery(c);
-
-  try {
-    await memoryService.initialize();
-
-    const events = await memoryService.getEventsByTurn(turnId);
-
-    if (events.length === 0) {
-      return c.json({ error: 'Turn not found' }, 404);
-    }
-
-    const promptEvent = events.find(e => e.eventType === 'user_prompt');
-    const toolEvents = events.filter(e => e.eventType === 'tool_observation');
-    const responseEvents = events.filter(e => e.eventType === 'agent_response');
-
-    return c.json({
-      turnId,
-      sessionId: events[0].sessionId,
-      startedAt: events[0].timestamp instanceof Date
-        ? events[0].timestamp.toISOString()
-        : events[0].timestamp,
-      prompt: promptEvent ? {
-        id: promptEvent.id,
-        content: promptEvent.content,
-        timestamp: promptEvent.timestamp instanceof Date
-          ? promptEvent.timestamp.toISOString()
-          : promptEvent.timestamp
-      } : null,
-      tools: toolEvents.map(e => {
-        let toolName = '';
-        let success = true;
-        try {
-          const parsed = JSON.parse(e.content);
-          toolName = parsed.toolName || '';
-          success = parsed.success !== false;
-        } catch { /* ignore */ }
-
-        return {
-          id: e.id,
-          toolName,
-          success,
-          timestamp: e.timestamp instanceof Date ? e.timestamp.toISOString() : e.timestamp,
-          preview: e.content.slice(0, 500) + (e.content.length > 500 ? '...' : '')
-        };
-      }),
-      responses: responseEvents.map(e => ({
-        id: e.id,
-        content: e.content,
-        timestamp: e.timestamp instanceof Date ? e.timestamp.toISOString() : e.timestamp
-      })),
-      totalEvents: events.length
-    });
-  } catch (error) {
-    return c.json({ error: (error as Error).message }, 500);
-  } finally {
-    await memoryService.shutdown();
-  }
-});
-
-// POST /api/turns/backfill - Backfill turn_ids from metadata
-turnsRouter.post('/backfill', async (c) => {
-  const memoryService = getServiceFromQuery(c);
-
-  try {
-    await memoryService.initialize();
-    const updated = await memoryService.backfillTurnIds();
-
-    return c.json({
-      success: true,
-      updated,
-      message: `Backfilled turn_id for ${updated} events`
-    });
-  } catch (error) {
-    return c.json({
-      success: false,
-      error: (error as Error).message
-    }, 500);
-  } finally {
-    await memoryService.shutdown();
-  }
-});

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

@@ -1,65 +0,0 @@
-/**
- * API Utilities
- * Shared helpers for API endpoints
- */
-
-import type { Context } from 'hono';
-import {
-  DISABLED_SHARED_STORE_CONFIG,
-  getReadOnlyMemoryService,
-  MemoryService
-} from '../../../services/memory-service.js';
-import { resolveProjectStoragePath } from '../../../core/registry/project-path.js';
-
-/**
- * Get the appropriate MemoryService based on the ?project= query parameter.
- * - If ?project=<hash> is set (8 hex chars), resolves directly to project storage
- * - If ?project=<path> is set, computes hash from path
- * - Otherwise, returns the global read-only service
- *
- * Always creates read-only services for the dashboard API to avoid
- * VectorWorker lifecycle issues with per-request services.
- */
-export function getServiceFromQuery(c: Context): MemoryService {
-  const project = c.req.query('project') || c.req.query('projectId');
-  if (project) {
-    const storagePath = resolveProjectStoragePath(project);
-
-    return new MemoryService({
-      storagePath,
-      readOnly: true,
-      analyticsEnabled: false,
-      sharedStoreConfig: DISABLED_SHARED_STORE_CONFIG
-    });
-  }
-  return getReadOnlyMemoryService();
-}
-
-
-/**
- * Read-only lightweight service for API paths that only need sqlite/keyword reads.
- * This avoids per-request vector/embedder/shared-store initialization for stats and
- * explicit fast searches while preserving the same project query resolution rules.
- */
-export function getLightweightServiceFromQuery(c: Context): MemoryService {
-  const project = c.req.query('project') || c.req.query('projectId');
-  if (project) {
-    const storagePath = resolveProjectStoragePath(project);
-
-    return new MemoryService({
-      storagePath,
-      readOnly: true,
-      lightweightMode: true,
-      analyticsEnabled: false,
-      sharedStoreConfig: DISABLED_SHARED_STORE_CONFIG
-    });
-  }
-
-  return new MemoryService({
-    storagePath: '~/.claude-code/memory',
-    readOnly: true,
-    lightweightMode: true,
-    analyticsEnabled: false,
-    sharedStoreConfig: DISABLED_SHARED_STORE_CONFIG
-  });
-}

package/src/apps/server/index.ts

@@ -1,111 +0,0 @@
-/**
- * Web Viewer HTTP Server
- * Provides REST API and serves static UI files
- */
-
-import { Hono } from 'hono';
-import { cors } from 'hono/cors';
-import { logger } from 'hono/logger';
-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 { fileURLToPath as fileUrlToPath } from 'url';
-
-import { apiRouter } from './api/index.js';
-
-const app = new Hono();
-const moduleDir = path.dirname(fileUrlToPath(import.meta.url));
-
-// Middleware
-app.use('/*', cors());
-app.use('/*', logger());
-
-// API routes
-app.route('/api', apiRouter);
-
-// Health check
-app.get('/health', (c) => c.json({ status: 'ok', timestamp: new Date().toISOString() }));
-
-function resolveUiPath(): string {
-  const candidates = [
-    // Built server: dist/server/index.js -> dist/ui
-    path.resolve(moduleDir, '../ui'),
-    // Source/dev server: src/apps/server/index.ts -> src/apps/dashboard
-    path.resolve(moduleDir, '../dashboard'),
-    // Fallback when running from a repository root.
-    path.resolve(process.cwd(), 'dist/ui'),
-    path.resolve(process.cwd(), 'src/apps/dashboard')
-  ];
-
-  return candidates.find((candidate) => fs.existsSync(path.join(candidate, 'index.html'))) ?? candidates[0];
-}
-
-// Static files (UI)
-const uiPath = resolveUiPath();
-if (fs.existsSync(uiPath)) {
-  app.use('/*', serveStatic({ root: uiPath }));
-}
-
-// Fallback for SPA routing
-app.get('*', (c) => {
-  const indexPath = path.join(uiPath, 'index.html');
-  if (fs.existsSync(indexPath)) {
-    return c.html(fs.readFileSync(indexPath, 'utf-8'));
-  }
-  return c.text('UI not built. Run "npm run build:ui" first.', 404);
-});
-
-export { app };
-
-let serverInstance: ReturnType<typeof serve> | null = null;
-
-/**
- * Start the HTTP server
- */
-export function startServer(port: number = 37777): NonNullable<ReturnType<typeof serve>> {
-  if (serverInstance) {
-    return serverInstance;
-  }
-
-  serverInstance = serve({
-    fetch: app.fetch,
-    port,
-    hostname: '127.0.0.1'
-  });
-
-  console.log(`🧠 Code Memory viewer started at http://localhost:${port}`);
-
-  return serverInstance;
-}
-
-/**
- * Stop the HTTP server
- */
-export function stopServer(): void {
-  if (serverInstance) {
-    serverInstance.close();
-    serverInstance = null;
-  }
-}
-
-/**
- * Check if server is running on given port
- */
-export async function isServerRunning(port: number = 37777): Promise<boolean> {
-  try {
-    const response = await fetch(`http://127.0.0.1:${port}/health`);
-    return response.ok;
-  } catch {
-    return false;
-  }
-}
-
-// Start server if run directly
-// 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);
-}

package/src/cli/index.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-/** Compatibility CLI entrypoint. Real app lives in src/apps/cli. */
-import '../apps/cli/index.js';

package/src/cli/retrieval-disclosure-output.ts

@@ -1,2 +0,0 @@
-/** Compatibility re-exports for the CLI disclosure formatters. */
-export * from '../apps/cli/retrieval-disclosure-output.js';

package/src/compat/index.ts

@@ -1,5 +0,0 @@
-/**
- * Compatibility layer for incremental thin-core migration.
- */
-
-export {};

package/src/core/canonical-key.ts

@@ -1,186 +0,0 @@
-/**
- * AXIOMMIND canonical_key.py port
- * Deterministic normalization ensuring identical titles always map to same keys
- */
-
-import { createHash } from 'crypto';
-
-const MAX_KEY_LENGTH = 200;
-
-/**
- * Convert text to a normalized canonical key
- *
- * Normalization steps:
- * 1. NFKC unicode normalization
- * 2. Lowercase conversion
- * 3. Punctuation removal
- * 4. Consecutive whitespace cleanup
- * 5. Context addition (optional)
- * 6. Long key truncation with MD5
- */
-export function makeCanonicalKey(
-  title: string,
-  context?: { project?: string; sessionId?: string }
-): string {
-  // Step 1: NFKC normalization
-  let normalized = title.normalize('NFKC');
-
-  // Step 2: Lowercase conversion
-  normalized = normalized.toLowerCase();
-
-  // Step 3: Punctuation removal (unicode compatible)
-  normalized = normalized.replace(/[^\p{L}\p{N}\s]/gu, '');
-
-  // Step 4: Consecutive whitespace cleanup
-  normalized = normalized.replace(/\s+/g, ' ').trim();
-
-  // Step 5: Context addition
-  let key = normalized;
-  if (context?.project) {
-    key = `${context.project}::${key}`;
-  }
-
-  // Step 6: Long key handling
-  if (key.length > MAX_KEY_LENGTH) {
-    const hashSuffix = createHash('md5').update(key).digest('hex').slice(0, 8);
-    key = key.slice(0, MAX_KEY_LENGTH - 9) + '_' + hashSuffix;
-  }
-
-  return key;
-}
-
-/**
- * Check if two texts have the same canonical key
- */
-export function isSameCanonicalKey(a: string, b: string): boolean {
-  return makeCanonicalKey(a) === makeCanonicalKey(b);
-}
-
-/**
- * Generate dedupe key (content + session for uniqueness)
- * AXIOMMIND Principle 3: Idempotency guarantee
- */
-export function makeDedupeKey(content: string, sessionId: string): string {
-  const contentHash = createHash('sha256').update(content).digest('hex');
-  return `${sessionId}:${contentHash}`;
-}
-
-/**
- * Generate content hash for deduplication
- */
-export function hashContent(content: string): string {
-  return createHash('sha256').update(content).digest('hex');
-}
-
-// ============================================================
-// Entity Canonical Keys (Task Entity System)
-// ============================================================
-
-export type EntityKeyType = 'task' | 'condition' | 'artifact';
-
-/**
- * Normalize text for entity key generation
- */
-function normalizeForKey(text: string): string {
-  return text
-    .normalize('NFKC')
-    .toLowerCase()
-    .replace(/[^\p{L}\p{N}\s]/gu, '')
-    .replace(/\s+/g, '_')
-    .trim();
-}
-
-/**
- * Generate canonical key for entities
- * Format: {type}:{project}:{normalized_identifier}
- */
-export function makeEntityCanonicalKey(
-  entityType: EntityKeyType,
-  identifier: string,
-  context?: { project?: string }
-): string {
-  const project = context?.project ?? 'default';
-
-  switch (entityType) {
-    case 'task':
-      return `task:${project}:${normalizeForKey(identifier)}`;
-    case 'condition':
-      return `cond:${project}:${normalizeForKey(identifier)}`;
-    case 'artifact':
-      return makeArtifactKey(identifier);
-  }
-}
-
-/**
- * Generate canonical key for artifacts based on identifier pattern
- * - URL: art:url:{sha1(url)}
- * - JIRA key: art:jira:{key}
- * - GitHub issue: art:gh_issue:{repo}:{num}
- * - Generic: art:generic:{sha1(identifier)}
- */
-export function makeArtifactKey(identifier: string): string {
-  // URL pattern
-  if (/^https?:\/\//.test(identifier)) {
-    const hash = createHash('sha1').update(identifier).digest('hex').slice(0, 12);
-    return `art:url:${hash}`;
-  }
-
-  // JIRA key pattern (e.g., PROJ-123)
-  const jiraMatch = identifier.match(/^([A-Z]+-\d+)$/);
-  if (jiraMatch) {
-    return `art:jira:${jiraMatch[1].toLowerCase()}`;
-  }
-
-  // GitHub issue pattern (e.g., owner/repo#123)
-  const ghMatch = identifier.match(/^([^\/]+\/[^#]+)#(\d+)$/);
-  if (ghMatch) {
-    return `art:gh_issue:${ghMatch[1]}:${ghMatch[2]}`;
-  }
-
-  // Generic identifier
-  const hash = createHash('sha1').update(identifier).digest('hex').slice(0, 12);
-  return `art:generic:${hash}`;
-}
-
-/**
- * Generate dedupe key for task events
- */
-export function makeTaskEventDedupeKey(
-  eventType: string,
-  taskId: string,
-  sessionId: string,
-  additionalContext?: string
-): string {
-  const parts = [eventType, taskId, sessionId];
-  if (additionalContext) {
-    parts.push(additionalContext);
-  }
-  const combined = parts.join(':');
-  return createHash('sha256').update(combined).digest('hex');
-}
-
-/**
- * Parse entity canonical key to extract type and identifier
- */
-export function parseEntityCanonicalKey(canonicalKey: string): {
-  entityType: EntityKeyType;
-  project?: string;
-  identifier: string;
-} | null {
-  const taskMatch = canonicalKey.match(/^task:([^:]+):(.+)$/);
-  if (taskMatch) {
-    return { entityType: 'task', project: taskMatch[1], identifier: taskMatch[2] };
-  }
-
-  const condMatch = canonicalKey.match(/^cond:([^:]+):(.+)$/);
-  if (condMatch) {
-    return { entityType: 'condition', project: condMatch[1], identifier: condMatch[2] };
-  }
-
-  const artMatch = canonicalKey.match(/^art:([^:]+):(.+)$/);
-  if (artMatch) {
-    return { entityType: 'artifact', identifier: artMatch[2] };
-  }
-
-  return null;
-}

package/src/core/citation-generator.ts

@@ -1,63 +0,0 @@
-/**
- * Citation Generator
- * Generates unique, short citation IDs for memory references
- */
-
-import { createHash } from 'crypto';
-
-const ID_LENGTH = 6;
-const CHARSET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-
-/**
- * Generate a citation ID from an event ID using SHA256
- */
-export function generateCitationId(eventId: string): string {
-  const hash = createHash('sha256')
-    .update(eventId)
-    .digest();
-
-  let id = '';
-  for (let i = 0; i < ID_LENGTH; i++) {
-    id += CHARSET[hash[i] % CHARSET.length];
-  }
-
-  return id;
-}
-
-/**
- * Generate a unique citation ID with collision handling
- */
-export async function generateUniqueCitationId(
-  eventId: string,
-  existsCheck: (id: string) => Promise<boolean>
-): Promise<string> {
-  let id = generateCitationId(eventId);
-  let attempt = 0;
-
-  while (await existsCheck(id) && attempt < 10) {
-    // Add salt and regenerate
-    id = generateCitationId(`${eventId}:${attempt}`);
-    attempt++;
-  }
-
-  if (attempt >= 10) {
-    throw new Error('Failed to generate unique citation ID after 10 attempts');
-  }
-
-  return id;
-}
-
-/**
- * Format a citation ID for display
- */
-export function formatCitationId(citationId: string): string {
-  return `[mem:${citationId}]`;
-}
-
-/**
- * Parse a citation ID from formatted string
- */
-export function parseCitationId(formatted: string): string | null {
-  const match = formatted.match(/\[?mem:([A-Za-z0-9]{6})\]?/);
-  return match ? match[1] : null;
-}