claude-memory-layer 1.0.31 → 1.0.32

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

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

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