claude-memory-layer 1.0.26 → 1.0.28

package/src/server/api/turns.ts

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

package/src/server/api/utils.ts

@@ -1,46 +1,2 @@
-/**
- * API Utilities
- * Shared helpers for API endpoints
- */
-
-import type { Context } from 'hono';
-import * as path from 'path';
-import * as os from 'os';
-import { getReadOnlyMemoryService } from '../../services/memory-service.js';
-import { MemoryService } from '../../services/memory-service.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) {
-    // Check if it's a hash (8 hex chars) or a path
-    const isHash = /^[a-f0-9]{8}$/.test(project);
-    let storagePath: string;
-
-    if (isHash) {
-      storagePath = path.join(os.homedir(), '.claude-code', 'memory', 'projects', project);
-    } else {
-      // Import hashProjectPath dynamically to compute the hash from path
-      const crypto = require('crypto');
-      const normalized = project.replace(/\/+$/, '') || '/';
-      const hash = crypto.createHash('sha256').update(normalized).digest('hex').slice(0, 8);
-      storagePath = path.join(os.homedir(), '.claude-code', 'memory', 'projects', hash);
-    }
-
-    return new MemoryService({
-      storagePath,
-      readOnly: true,
-      analyticsEnabled: false,
-      sharedStoreConfig: { enabled: false }
-    });
-  }
-  return getReadOnlyMemoryService();
-}
+/** Compatibility API module. Real app lives in src/apps/server/api. */
+export * from '../../apps/server/api/utils.js';

package/src/server/index.ts

@@ -1,100 +1,2 @@
-/**
- * Web Viewer HTTP Server
- * Provides REST API and serves static UI files
- */
-
-// These are injected by the esbuild banner
-declare const __dirname: string;
-declare const __filename: string;
-
-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 type { Server } from 'http';
-
-import { apiRouter } from './api/index.js';
-
-const app = new Hono();
-
-// 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() }));
-
-// Static files (UI)
-const uiPath = path.join(__dirname, '../../dist/ui');
-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: Server | null = null;
-
-/**
- * Start the HTTP server
- */
-export function startServer(port: number = 37777): Server {
-  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);
-}
+/** Compatibility server entrypoint. Real app lives in src/apps/server. */
+export * from '../apps/server/index.js';

package/src/services/bootstrap-organizer.ts

@@ -103,37 +103,52 @@ function runGit(repoPath: string, command: string): string {
   return execSync(`git -C ${JSON.stringify(repoPath)} ${command}`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
 }
 
+function parseGitLog(raw: string): CommitInfo[] {
+  const lines = raw.split(/\r?\n/);
+  const commits: CommitInfo[] = [];
+  let current: CommitInfo | null = null;
+
+  for (const line of lines) {
+    if (!line.trim()) {
+      if (current) {
+        commits.push(current);
+        current = null;
+      }
+      continue;
+    }
+
+    if (line.includes('\t') && line.split('\t').length >= 4) {
+      if (current) commits.push(current);
+      const [hash, date, author, ...subjectRest] = line.split('\t');
+      current = { hash, date, author, subject: subjectRest.join('\t').trim(), files: [] };
+    } else if (current) {
+      current.files.push(line.trim());
+    }
+  }
+
+  if (current) commits.push(current);
+  return commits;
+}
+
 function getGitCommits(repoPath: string, since = '180 days ago', maxCommits = 1000): CommitInfo[] {
   try {
     const raw = runGit(
       repoPath,
       `log --since=${JSON.stringify(since)} -n ${Math.max(1, maxCommits)} --date=short --pretty=format:%H%x09%ad%x09%an%x09%s --name-only --reverse`
     );
+    return parseGitLog(raw);
+  } catch {
+    return [];
+  }
+}
 
-    const lines = raw.split(/\r?\n/);
-    const commits: CommitInfo[] = [];
-    let current: CommitInfo | null = null;
-
-    for (const line of lines) {
-      if (!line.trim()) {
-        if (current) {
-          commits.push(current);
-          current = null;
-        }
-        continue;
-      }
-
-      if (line.includes('\t') && line.split('\t').length >= 4) {
-        if (current) commits.push(current);
-        const [hash, date, author, ...subjectRest] = line.split('\t');
-        current = { hash, date, author, subject: subjectRest.join('\t').trim(), files: [] };
-      } else if (current) {
-        current.files.push(line.trim());
-      }
-    }
-
-    if (current) commits.push(current);
-    return commits;
+function getGitCommitsAfterHash(repoPath: string, hash: string, maxCommits = 1000): CommitInfo[] {
+  try {
+    const raw = runGit(
+      repoPath,
+      `log ${JSON.stringify(`${hash}..HEAD`)} -n ${Math.max(1, maxCommits)} --date=short --pretty=format:%H%x09%ad%x09%an%x09%s --name-only --reverse`
+    );
+    return parseGitLog(raw);
   } catch {
     return [];
   }
@@ -194,6 +209,7 @@ function sourceLine(source: string): string {
 interface ExistingManifest {
   generatedAt?: string;
   lastCommitDate?: string;
+  lastCommitHash?: string;
 }
 
 function loadExistingManifest(outDir: string): ExistingManifest | null {
@@ -238,7 +254,9 @@ export async function bootstrapKnowledgeBase(options: BootstrapKnowledgeOptions)
 
   const codeFiles = walkCodeFiles(repoPath);
   const modules = summarizeModules(repoPath, codeFiles);
-  const commits = getGitCommits(repoPath, since, maxCommits);
+  const commits = options.incremental && existingManifest?.lastCommitHash
+    ? getGitCommitsAfterHash(repoPath, existingManifest.lastCommitHash, maxCommits)
+    : getGitCommits(repoPath, since, maxCommits);
   const decisions = extractDecisions(commits);
   const timeline = buildTimeline(commits);
   const glossary = buildGlossary(codeFiles);
@@ -390,7 +408,8 @@ export async function bootstrapKnowledgeBase(options: BootstrapKnowledgeOptions)
     ...commits.slice(0, 400).map((c) => ({ type: 'commit', ref: c.hash, date: c.date, subject: c.subject }))
   ];
 
-  const latestCommitDate = commits.length > 0 ? commits[commits.length - 1].date : undefined;
+  const latestCommitDate = commits.length > 0 ? commits[commits.length - 1].date : existingManifest?.lastCommitDate;
+  const latestCommitHash = commits.length > 0 ? commits[commits.length - 1].hash : existingManifest?.lastCommitHash;
   const manifest = {
     generatedAt: new Date().toISOString(),
     deterministicPipeline: true,
@@ -406,6 +425,7 @@ export async function bootstrapKnowledgeBase(options: BootstrapKnowledgeOptions)
       glossaryTerms: glossary.length
     },
     lastCommitDate: latestCommitDate,
+    lastCommitHash: latestCommitHash,
     outputs,
     allOutputs,
     sources: sourceItems