claude-memory-layer 1.0.26 → 1.0.28

package/src/server/api/projects.ts

@@ -1,74 +1,2 @@
-/**
- * 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];
-}
+/** Compatibility API module. Real app lives in src/apps/server/api. */
+export * from '../../apps/server/api/projects.js';

package/src/server/api/search.ts

@@ -1,102 +1,2 @@
-/**
- * Search API
- * Endpoints for memory search
- */
-
-import { Hono } from 'hono';
-import { getServiceFromQuery } from './utils.js';
-
-export const searchRouter = new Hono();
-
-interface SearchRequest {
-  query: string;
-  options?: {
-    topK?: number;
-    minScore?: number;
-    sessionId?: string;
-    eventType?: string;
-  };
-}
-
-// 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();
-  }
-});
-
-// 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();
-  }
-});
+/** Compatibility API module. Real app lives in src/apps/server/api. */
+export * from '../../apps/server/api/search.js';

package/src/server/api/sessions.ts

@@ -1,115 +1,2 @@
-/**
- * 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();
-  }
-});
+/** Compatibility API module. Real app lives in src/apps/server/api. */
+export * from '../../apps/server/api/sessions.js';