claude-memory-layer 1.0.6 → 1.0.7

package/dist/cli/index.js

@@ -8,6 +8,7 @@ const __dirname = dirname(__filename);
 
 // src/cli/index.ts
 import { Command } from "commander";
+import { exec } from "child_process";
 
 // src/services/memory-service.ts
 import * as path from "path";
@@ -70,8 +71,8 @@ function toDate(value) {
     return new Date(value);
   return new Date(String(value));
 }
-function createDatabase(path3) {
-  return new duckdb.Database(path3);
+function createDatabase(path4) {
+  return new duckdb.Database(path4);
 }
 function dbRun(db, sql, params = []) {
   return new Promise((resolve2, reject) => {
@@ -4158,9 +4159,506 @@ function createSessionHistoryImporter(memoryService) {
   return new SessionHistoryImporter(memoryService);
 }
 
+// src/server/index.ts
+import { Hono as Hono7 } from "hono";
+import { cors } from "hono/cors";
+import { logger } from "hono/logger";
+import { serveStatic } from "hono/bun";
+import * as path3 from "path";
+import * as fs3 from "fs";
+
+// src/server/api/index.ts
+import { Hono as Hono6 } from "hono";
+
+// src/server/api/sessions.ts
+import { Hono } from "hono";
+var sessionsRouter = new Hono();
+sessionsRouter.get("/", async (c) => {
+  const page = parseInt(c.req.query("page") || "1", 10);
+  const pageSize = parseInt(c.req.query("pageSize") || "20", 10);
+  try {
+    const memoryService = getDefaultMemoryService();
+    await memoryService.initialize();
+    const recentEvents = await memoryService.getRecentEvents(1e3);
+    const sessionMap = /* @__PURE__ */ new Map();
+    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.message }, 500);
+  }
+});
+sessionsRouter.get("/:id", async (c) => {
+  const { id } = c.req.param();
+  try {
+    const memoryService = getDefaultMemoryService();
+    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.message }, 500);
+  }
+});
+
+// src/server/api/events.ts
+import { Hono as Hono2 } from "hono";
+var eventsRouter = new Hono2();
+eventsRouter.get("/", async (c) => {
+  const sessionId = c.req.query("sessionId");
+  const eventType = c.req.query("type");
+  const limit = parseInt(c.req.query("limit") || "100", 10);
+  const offset = parseInt(c.req.query("offset") || "0", 10);
+  try {
+    const memoryService = getDefaultMemoryService();
+    await memoryService.initialize();
+    let events = await memoryService.getRecentEvents(limit + offset + 1e3);
+    if (sessionId) {
+      events = events.filter((e) => e.sessionId === sessionId);
+    }
+    if (eventType) {
+      events = events.filter((e) => e.eventType === eventType);
+    }
+    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
+      })),
+      total,
+      limit,
+      offset,
+      hasMore: offset + limit < total
+    });
+  } catch (error) {
+    return c.json({ error: error.message }, 500);
+  }
+});
+eventsRouter.get("/:id", async (c) => {
+  const { id } = c.req.param();
+  try {
+    const memoryService = getDefaultMemoryService();
+    await memoryService.initialize();
+    const recentEvents = await memoryService.getRecentEvents(1e4);
+    const event = recentEvents.find((e) => e.id === id);
+    if (!event) {
+      return c.json({ error: "Event not found" }, 404);
+    }
+    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.message }, 500);
+  }
+});
+
+// src/server/api/search.ts
+import { Hono as Hono3 } from "hono";
+var searchRouter = new Hono3();
+searchRouter.post("/", async (c) => {
+  try {
+    const body = await c.req.json();
+    if (!body.query) {
+      return c.json({ error: "Query is required" }, 400);
+    }
+    const memoryService = getDefaultMemoryService();
+    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.message }, 500);
+  }
+});
+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);
+  try {
+    const memoryService = getDefaultMemoryService();
+    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.message }, 500);
+  }
+});
+
+// src/server/api/stats.ts
+import { Hono as Hono4 } from "hono";
+var statsRouter = new Hono4();
+statsRouter.get("/shared", async (c) => {
+  try {
+    const memoryService = getDefaultMemoryService();
+    await memoryService.initialize();
+    const sharedStats = await memoryService.getSharedStoreStats();
+    return c.json({
+      troubleshooting: sharedStats?.troubleshooting || 0,
+      bestPractices: sharedStats?.bestPractices || 0,
+      commonErrors: sharedStats?.commonErrors || 0,
+      totalUsageCount: sharedStats?.totalUsageCount || 0,
+      lastUpdated: sharedStats?.lastUpdated || null
+    });
+  } catch (error) {
+    return c.json({
+      troubleshooting: 0,
+      bestPractices: 0,
+      commonErrors: 0,
+      totalUsageCount: 0,
+      lastUpdated: null
+    });
+  }
+});
+statsRouter.get("/endless", async (c) => {
+  try {
+    const projectPath = c.req.query("project") || process.cwd();
+    const memoryService = getMemoryServiceForProject(projectPath);
+    await memoryService.initialize();
+    const status = await memoryService.getEndlessModeStatus();
+    return c.json({
+      mode: status.mode,
+      continuityScore: status.continuityScore,
+      workingSetSize: status.workingSetSize,
+      consolidatedCount: status.consolidatedCount,
+      lastConsolidation: status.lastConsolidation?.toISOString() || null
+    });
+  } catch (error) {
+    return c.json({
+      mode: "session",
+      continuityScore: 0,
+      workingSetSize: 0,
+      consolidatedCount: 0,
+      lastConsolidation: null
+    });
+  }
+});
+statsRouter.get("/", async (c) => {
+  try {
+    const memoryService = getDefaultMemoryService();
+    await memoryService.initialize();
+    const stats = await memoryService.getStats();
+    const recentEvents = await memoryService.getRecentEvents(1e4);
+    const eventsByType = recentEvents.reduce((acc, e) => {
+      acc[e.eventType] = (acc[e.eventType] || 0) + 1;
+      return acc;
+    }, {});
+    const uniqueSessions = new Set(recentEvents.map((e) => e.sessionId));
+    const now = /* @__PURE__ */ new Date();
+    const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1e3);
+    const eventsByDay = recentEvents.filter((e) => e.timestamp >= sevenDaysAgo).reduce((acc, e) => {
+      const day = e.timestamp.toISOString().split("T")[0];
+      acc[day] = (acc[day] || 0) + 1;
+      return acc;
+    }, {});
+    return c.json({
+      storage: {
+        eventCount: stats.totalEvents,
+        vectorCount: stats.vectorCount
+      },
+      sessions: {
+        total: uniqueSessions.size
+      },
+      eventsByType,
+      activity: {
+        daily: eventsByDay,
+        total7Days: recentEvents.filter((e) => e.timestamp >= sevenDaysAgo).length
+      },
+      memory: {
+        heapUsed: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
+        heapTotal: Math.round(process.memoryUsage().heapTotal / 1024 / 1024)
+      },
+      levelStats: stats.levelStats
+    });
+  } catch (error) {
+    return c.json({ error: error.message }, 500);
+  }
+});
+statsRouter.get("/timeline", async (c) => {
+  const days = parseInt(c.req.query("days") || "7", 10);
+  try {
+    const memoryService = getDefaultMemoryService();
+    await memoryService.initialize();
+    const recentEvents = await memoryService.getRecentEvents(1e4);
+    const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1e3);
+    const filteredEvents = recentEvents.filter((e) => e.timestamp >= cutoff);
+    const daily = filteredEvents.reduce((acc, e) => {
+      const day = e.timestamp.toISOString().split("T")[0];
+      if (!acc[day]) {
+        acc[day] = { date: day, total: 0, prompts: 0, responses: 0, tools: 0 };
+      }
+      acc[day].total++;
+      if (e.eventType === "user_prompt")
+        acc[day].prompts++;
+      if (e.eventType === "agent_response")
+        acc[day].responses++;
+      if (e.eventType === "tool_observation")
+        acc[day].tools++;
+      return acc;
+    }, {});
+    return c.json({
+      days,
+      daily: Object.values(daily).sort((a, b) => a.date.localeCompare(b.date))
+    });
+  } catch (error) {
+    return c.json({ error: error.message }, 500);
+  }
+});
+
+// src/server/api/citations.ts
+import { Hono as Hono5 } from "hono";
+
+// src/core/citation-generator.ts
+import { createHash as createHash3 } from "crypto";
+var ID_LENGTH = 6;
+var CHARSET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+function generateCitationId(eventId) {
+  const hash = createHash3("sha256").update(eventId).digest();
+  let id = "";
+  for (let i = 0; i < ID_LENGTH; i++) {
+    id += CHARSET[hash[i] % CHARSET.length];
+  }
+  return id;
+}
+function parseCitationId(formatted) {
+  const match = formatted.match(/\[?mem:([A-Za-z0-9]{6})\]?/);
+  return match ? match[1] : null;
+}
+
+// src/server/api/citations.ts
+var citationsRouter = new Hono5();
+citationsRouter.get("/:id", async (c) => {
+  const { id } = c.req.param();
+  const citationId = parseCitationId(id) || id;
+  try {
+    const memoryService = getDefaultMemoryService();
+    await memoryService.initialize();
+    const recentEvents = await memoryService.getRecentEvents(1e4);
+    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.message }, 500);
+  }
+});
+citationsRouter.get("/:id/related", async (c) => {
+  const { id } = c.req.param();
+  const citationId = parseCitationId(id) || id;
+  try {
+    const memoryService = getDefaultMemoryService();
+    await memoryService.initialize();
+    const recentEvents = await memoryService.getRecentEvents(1e4);
+    const event = recentEvents.find((e) => {
+      const eventCitationId = generateCitationId(e.id);
+      return eventCitationId === citationId;
+    });
+    if (!event) {
+      return c.json({ error: "Citation not found" }, 404);
+    }
+    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.message }, 500);
+  }
+});
+
+// src/server/api/index.ts
+var apiRouter = new Hono6().route("/sessions", sessionsRouter).route("/events", eventsRouter).route("/search", searchRouter).route("/stats", statsRouter).route("/citations", citationsRouter);
+
+// src/server/index.ts
+var app = new Hono7();
+app.use("/*", cors());
+app.use("/*", logger());
+app.route("/api", apiRouter);
+app.get("/health", (c) => c.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+var uiPath = path3.join(import.meta.dir, "../../dist/ui");
+if (fs3.existsSync(uiPath)) {
+  app.use("/*", serveStatic({ root: uiPath }));
+}
+app.get("*", (c) => {
+  const indexPath = path3.join(uiPath, "index.html");
+  if (fs3.existsSync(indexPath)) {
+    return c.html(fs3.readFileSync(indexPath, "utf-8"));
+  }
+  return c.text('UI not built. Run "npm run build:ui" first.', 404);
+});
+var serverInstance = null;
+function startServer(port = 37777) {
+  if (serverInstance) {
+    return serverInstance;
+  }
+  serverInstance = Bun.serve({
+    hostname: "127.0.0.1",
+    port,
+    fetch: app.fetch
+  });
+  console.log(`\u{1F9E0} Code Memory viewer started at http://localhost:${port}`);
+  return serverInstance;
+}
+function stopServer() {
+  if (serverInstance) {
+    serverInstance.stop();
+    serverInstance = null;
+  }
+}
+async function isServerRunning(port = 37777) {
+  try {
+    const response = await fetch(`http://127.0.0.1:${port}/health`);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+if (import.meta.main) {
+  const port = parseInt(process.env.PORT || "37777", 10);
+  startServer(port);
+}
+
 // src/cli/index.ts
 var program = new Command();
-program.name("code-memory").description("Claude Code Memory Plugin CLI").version("1.0.0");
+program.name("claude-memory-layer").description("Claude Code Memory Plugin CLI").version("1.0.0");
 program.command("search <query>").description("Search memories using semantic search").option("-k, --top-k <number>", "Number of results", "5").option("-s, --min-score <number>", "Minimum similarity score", "0.7").option("--session <id>", "Filter by session ID").option("-p, --project <path>", "Project path (defaults to cwd)").action(async (query, options) => {
   const projectPath = options.project || process.cwd();
   const service = getMemoryServiceForProject(projectPath);
@@ -4384,7 +4882,7 @@ program.command("list").description("List available Claude Code sessions").optio
     if (sessions.length > 20) {
       console.log(`... and ${sessions.length - 20} more sessions`);
     }
-    console.log('\nUse "code-memory import --session <path>" to import a specific session');
+    console.log('\nUse "claude-memory-layer import --session <path>" to import a specific session');
   } catch (error) {
     console.error("List failed:", error);
     process.exit(1);
@@ -4404,7 +4902,7 @@ endlessCmd.command("enable").description("Enable Endless Mode").option("-p, --pr
     console.log("  - Working Set: Recent context kept active");
     console.log("  - Consolidation: Automatic memory integration");
     console.log("  - Continuity: Seamless context transitions\n");
-    console.log('Use "code-memory endless status" to view current state');
+    console.log('Use "claude-memory-layer endless status" to view current state');
     await service.shutdown();
   } catch (error) {
     console.error("Enable failed:", error);
@@ -4452,7 +4950,7 @@ ${modeIcon} ${modeName}
       }
     } else {
       console.log("Endless Mode is disabled.");
-      console.log('Use "code-memory endless enable" to activate.');
+      console.log('Use "claude-memory-layer endless enable" to activate.');
     }
     await service.shutdown();
   } catch (error) {
@@ -4467,7 +4965,7 @@ endlessCmd.command("consolidate").description("Manually trigger memory consolida
     await service.initialize();
     if (!service.isEndlessModeActive()) {
       console.log("\n\u26A0\uFE0F  Endless Mode is not active");
-      console.log('Use "code-memory endless enable" first');
+      console.log('Use "claude-memory-layer endless enable" first');
       process.exit(1);
     }
     console.log("\n\u23F3 Running memory consolidation...");
@@ -4492,7 +4990,7 @@ endlessCmd.command("working-set").alias("ws").description("View current working
     await service.initialize();
     if (!service.isEndlessModeActive()) {
       console.log("\n\u26A0\uFE0F  Endless Mode is not active");
-      console.log('Use "code-memory endless enable" first');
+      console.log('Use "claude-memory-layer endless enable" first');
       process.exit(1);
     }
     const workingSet = await service.getWorkingSet();
@@ -4568,5 +5066,61 @@ endlessCmd.command("memories").description("View consolidated memories").option(
     process.exit(1);
   }
 });
+program.command("dashboard").description("Open memory dashboard in browser").option("-p, --port <port>", "Server port", "37777").option("--no-open", "Do not auto-open browser").action(async (options) => {
+  const port = parseInt(options.port, 10);
+  try {
+    const running = await isServerRunning(port);
+    if (running) {
+      console.log(`
+\u{1F9E0} Dashboard already running at http://localhost:${port}
+`);
+      if (options.open) {
+        openBrowser(`http://localhost:${port}`);
+      }
+      return;
+    }
+    console.log("\n\u{1F9E0} Starting Code Memory Dashboard...\n");
+    startServer(port);
+    if (options.open) {
+      setTimeout(() => {
+        openBrowser(`http://localhost:${port}`);
+      }, 500);
+    }
+    console.log(`
+\u{1F4CA} Dashboard: http://localhost:${port}`);
+    console.log("Press Ctrl+C to stop the server\n");
+    const shutdown = () => {
+      console.log("\n\n\u{1F44B} Shutting down dashboard...");
+      stopServer();
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    await new Promise(() => {
+    });
+  } catch (error) {
+    console.error("Dashboard failed:", error);
+    process.exit(1);
+  }
+});
+function openBrowser(url) {
+  const platform = process.platform;
+  let command;
+  if (platform === "darwin") {
+    command = `open "${url}"`;
+  } else if (platform === "win32") {
+    command = `start "" "${url}"`;
+  } else {
+    command = `xdg-open "${url}"`;
+  }
+  exec(command, (error) => {
+    if (error) {
+      console.log(`
+\u26A0\uFE0F  Could not open browser automatically.`);
+      console.log(`   Please open ${url} manually.
+`);
+    }
+  });
+}
 program.parse();
 //# sourceMappingURL=index.js.map