claude-memory-layer 1.0.54 → 1.0.55

package/dist/server/index.js

@@ -12,8 +12,8 @@ import { getCookie, setCookie, deleteCookie } from "hono/cookie";
 import { logger } from "hono/logger";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
-import * as path14 from "path";
-import * as fs12 from "fs";
+import * as path15 from "path";
+import * as fs13 from "fs";
 import { createHmac, timingSafeEqual } from "crypto";
 import { fileURLToPath as fileUrlToPath } from "url";
 
@@ -2255,12 +2255,12 @@ function resolveProjectStoragePath(projectOrHash) {
 import Database from "better-sqlite3";
 import * as fs4 from "fs";
 import * as nodePath from "path";
-function createSQLiteDatabase(path15, options) {
-  const dir = nodePath.dirname(path15);
+function createSQLiteDatabase(path16, options) {
+  const dir = nodePath.dirname(path16);
   if (!fs4.existsSync(dir)) {
     fs4.mkdirSync(dir, { recursive: true });
   }
-  const db = new Database(path15, {
+  const db = new Database(path16, {
     readonly: options?.readonly ?? false
   });
   if (!options?.readonly && (options?.walMode ?? true)) {
@@ -2723,17 +2723,17 @@ function emptyOutboxRecoveryResult() {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function getNestedRecord(root, path15) {
+function getNestedRecord(root, path16) {
   let cursor = root;
-  for (const key of path15) {
+  for (const key of path16) {
     if (!isRecord(cursor)) return void 0;
     cursor = cursor[key];
   }
   return isRecord(cursor) ? cursor : void 0;
 }
-function getNestedString(root, path15) {
+function getNestedString(root, path16) {
   let cursor = root;
-  for (const key of path15) {
+  for (const key of path16) {
     if (!isRecord(cursor)) return void 0;
     cursor = cursor[key];
   }
@@ -6696,12 +6696,12 @@ var GraphPathService = class {
         }
       }
     }
-    const paths = Array.from(bestByTarget.entries()).map(([key, path15]) => ({
+    const paths = Array.from(bestByTarget.entries()).map(([key, path16]) => ({
       target: graph.node(nodeFromKey(key)),
-      hops: path15.hops,
-      totalCost: path15.totalCost,
-      scoreContribution: path15.totalCost > 0 ? 1 / path15.totalCost : 0,
-      steps: path15.steps
+      hops: path16.hops,
+      totalCost: path16.totalCost,
+      scoreContribution: path16.totalCost > 0 ? 1 / path16.totalCost : 0,
+      steps: path16.steps
     })).sort((a, b) => b.scoreContribution - a.scoreContribution || a.hops - b.hops || a.target.name.localeCompare(b.target.name)).slice(0, maxResults);
     return { startNodes, effectiveMaxHops, paths };
   }
@@ -9474,12 +9474,12 @@ var Retriever = class {
         direction: "both"
       });
       const titleByEntityId = new Map(startNodes.map((node) => [node.entityId, node.title]));
-      for (const path15 of expansion.paths) {
-        if (path15.target.type !== "event") continue;
-        const target = await this.eventStore.getEvent(path15.target.id);
+      for (const path16 of expansion.paths) {
+        if (path16.target.type !== "event") continue;
+        const target = await this.eventStore.getEvent(path16.target.id);
         if (!target) continue;
-        const graphPath = toRetrievalGraphPathDebug(path15, titleByEntityId);
-        const score = graphPathScore(path15, opts.hopPenalty);
+        const graphPath = toRetrievalGraphPathDebug(path16, titleByEntityId);
+        const score = graphPathScore(path16, opts.hopPenalty);
         const existing = byId.get(target.id);
         const graphPaths = mergeGraphPaths(existing?.graphPaths ?? [], [graphPath]);
         const graphLane = {
@@ -9488,7 +9488,7 @@ var Retriever = class {
           score
         };
         const row = {
-          id: existing?.id ?? `graph-path-${path15.hops}-${target.id}`,
+          id: existing?.id ?? `graph-path-${path16.hops}-${target.id}`,
           eventId: target.id,
           content: target.content,
           score: Math.max(existing?.score ?? 0, score),
@@ -9828,8 +9828,8 @@ _Context:_ ${sessionContext}`;
   }
   matchesMetadataScope(metadata, expected) {
     if (!metadata) return false;
-    return Object.entries(expected).every(([path15, value]) => {
-      const actual = path15.split(".").reduce((acc, key) => {
+    return Object.entries(expected).every(([path16, value]) => {
+      const actual = path16.split(".").reduce((acc, key) => {
         if (typeof acc !== "object" || acc === null) return void 0;
         return acc[key];
       }, metadata);
@@ -9880,22 +9880,22 @@ function uniqueEntityStartNodes(candidates) {
   }
   return nodes;
 }
-function toRetrievalGraphPathDebug(path15, titleByEntityId) {
-  const firstStep = path15.steps[0];
+function toRetrievalGraphPathDebug(path16, titleByEntityId) {
+  const firstStep = path16.steps[0];
   const startNode = firstStep?.direction === "incoming" ? firstStep.to : firstStep?.from;
   const startEntityId = startNode?.type === "entity" ? startNode.id : "";
   return {
     startEntityId,
     startEntityTitle: titleByEntityId.get(startEntityId) ?? startNode?.name,
-    targetId: path15.target.id,
-    targetType: path15.target.type,
-    hops: path15.hops,
-    relationPath: path15.steps.map((step) => step.relationType)
+    targetId: path16.target.id,
+    targetType: path16.target.type,
+    hops: path16.hops,
+    relationPath: path16.steps.map((step) => step.relationType)
   };
 }
-function graphPathScore(path15, hopPenalty) {
-  const base = Math.min(0.95, Math.max(0, path15.scoreContribution));
-  return Math.max(0.05, base - hopPenalty * Math.max(0, path15.hops - 1));
+function graphPathScore(path16, hopPenalty) {
+  const base = Math.min(0.95, Math.max(0, path16.scoreContribution));
+  return Math.max(0.05, base - hopPenalty * Math.max(0, path16.hops - 1));
 }
 function clampGraphHops(maxHops) {
   if (!Number.isFinite(maxHops)) return 2;
@@ -9903,14 +9903,14 @@ function clampGraphHops(maxHops) {
 }
 function mergeGraphPaths(existing, incoming) {
   const byKey = /* @__PURE__ */ new Map();
-  for (const path15 of [...existing, ...incoming]) {
-    const key = [path15.startEntityId, path15.targetType, path15.targetId, path15.hops, ...path15.relationPath].join("\0");
-    if (!byKey.has(key)) byKey.set(key, path15);
+  for (const path16 of [...existing, ...incoming]) {
+    const key = [path16.startEntityId, path16.targetType, path16.targetId, path16.hops, ...path16.relationPath].join("\0");
+    if (!byKey.has(key)) byKey.set(key, path16);
   }
   return [...byKey.values()].sort((a, b) => a.hops - b.hops || compareStable(graphPathSignature(a), graphPathSignature(b))).slice(0, 3);
 }
-function graphPathSignature(path15) {
-  return [path15.startEntityId, path15.targetType, path15.targetId, path15.hops, ...path15.relationPath].join("|");
+function graphPathSignature(path16) {
+  return [path16.startEntityId, path16.targetType, path16.targetId, path16.hops, ...path16.relationPath].join("|");
 }
 function compareStable(a, b) {
   if (a < b) return -1;
@@ -15573,6 +15573,150 @@ function streamClaudeResponse(prompt, stream) {
 // src/apps/server/api/health.ts
 import { Hono as Hono9 } from "hono";
 import { spawnSync } from "child_process";
+import * as fs12 from "fs";
+import * as path14 from "path";
+
+// src/core/productivity-health-report.ts
+var PRODUCTIVITY_HEALTH_SCHEMA_VERSION = "agent-productivity-health-v1";
+var PRODUCTIVITY_HEALTH_PROFILES = ["coder", "reviewer", "pm", "support", "researcher", "team"];
+var PRODUCTIVITY_HEALTH_MODES = ["observe", "preview", "enforce"];
+function parseProductivityHealthProfile(value) {
+  const normalized = typeof value === "string" && value.trim().length > 0 ? value.trim() : "coder";
+  if (PRODUCTIVITY_HEALTH_PROFILES.includes(normalized)) {
+    return normalized;
+  }
+  throw new Error(`Invalid --profile: expected one of ${PRODUCTIVITY_HEALTH_PROFILES.join(", ")}`);
+}
+function parseProductivityHealthMode(value) {
+  const normalized = typeof value === "string" && value.trim().length > 0 ? value.trim() : "preview";
+  if (PRODUCTIVITY_HEALTH_MODES.includes(normalized)) {
+    return normalized;
+  }
+  throw new Error(`Invalid --mode: expected one of ${PRODUCTIVITY_HEALTH_MODES.join(", ")}`);
+}
+function buildProductivityHealthReport(input) {
+  const profile = input.profile ?? "coder";
+  const mode = input.mode ?? "preview";
+  const embedding = normalizeQueue(input.outbox.embedding);
+  const vector = normalizeQueue(input.outbox.vector);
+  const totals = sumQueues(embedding, vector);
+  const storage = {
+    totalEvents: numberOrZero(input.stats.totalEvents),
+    vectorCount: numberOrZero(input.stats.vectorCount),
+    levelStats: normalizeLevelStats(input.stats.levelStats)
+  };
+  const warningReasons = [];
+  const projectGate = buildProjectScopeGate(input.project);
+  const outboxGate = buildOutboxGate(totals);
+  const densityGate = buildMemoryDensityGate(storage.totalEvents);
+  const riskGates = [projectGate, outboxGate, densityGate];
+  if (projectGate.status === "warn") warningReasons.push("project_scope_unknown");
+  if (outboxGate.status === "warn") warningReasons.push("outbox_requires_attention");
+  if (densityGate.status === "warn") warningReasons.push("memory_density_low");
+  const status = riskGates.some((gate) => gate.status === "warn") ? "needs-attention" : "ok";
+  return {
+    schemaVersion: PRODUCTIVITY_HEALTH_SCHEMA_VERSION,
+    generatedAt: (input.generatedAt ?? /* @__PURE__ */ new Date()).toISOString(),
+    status,
+    profile,
+    mode,
+    project: input.project,
+    summary: { warningReasons },
+    signals: {
+      storage,
+      outbox: { embedding, vector, totals }
+    },
+    riskGates,
+    nextBestAction: selectNextBestAction({ projectGate, outboxGate, densityGate })
+  };
+}
+function buildProjectScopeGate(project) {
+  if (project.scope === "project") {
+    return { id: "project-scope-known", severity: "blocker", status: "pass" };
+  }
+  return {
+    id: "project-scope-known",
+    severity: "blocker",
+    status: "warn",
+    message: "No project parameter supplied; report uses global memory scope."
+  };
+}
+function buildOutboxGate(totals) {
+  if (totals.failed > 0 || totals.stuckProcessing > 0) {
+    return {
+      id: "outbox-healthy",
+      severity: "warning",
+      status: "warn",
+      message: "Outbox has failed or stuck processing items; run recovery before trusting retrieval freshness."
+    };
+  }
+  return { id: "outbox-healthy", severity: "warning", status: "pass" };
+}
+function buildMemoryDensityGate(totalEvents) {
+  if (totalEvents <= 0) {
+    return {
+      id: "memory-density",
+      severity: "warning",
+      status: "warn",
+      message: "No memories are available for this scope yet."
+    };
+  }
+  return { id: "memory-density", severity: "warning", status: "pass" };
+}
+function selectNextBestAction(input) {
+  if (input.outboxGate.status === "warn") {
+    return "Run claude-memory-layer process --dry-run-recovery, then process pending embeddings.";
+  }
+  if (input.densityGate.status === "warn") {
+    return "Import or capture project context before relying on productivity memory guidance.";
+  }
+  if (input.projectGate.status === "warn") {
+    return "Provide a project path or project hash before relying on project-scoped productivity guidance.";
+  }
+  return "No immediate maintenance action required.";
+}
+function normalizeLevelStats(levelStats) {
+  if (!Array.isArray(levelStats)) return [];
+  return levelStats.filter((entry) => typeof entry.level === "string" && entry.level.trim().length > 0).map((entry) => ({ level: entry.level.trim().slice(0, 20), count: numberOrZero(entry.count) }));
+}
+function normalizeQueue(queue) {
+  return {
+    pending: numberOrZero(queue.pending),
+    processing: numberOrZero(queue.processing),
+    failed: numberOrZero(queue.failed),
+    retryableFailed: numberOrZero(queue.retryableFailed),
+    quarantinedFailed: numberOrZero(queue.quarantinedFailed),
+    total: numberOrZero(queue.total),
+    stuckProcessing: numberOrZero(queue.stuckProcessing),
+    oldestProcessingAgeMs: normalizeNullableAge(queue.oldestProcessingAgeMs)
+  };
+}
+function sumQueues(a, b) {
+  return {
+    pending: a.pending + b.pending,
+    processing: a.processing + b.processing,
+    failed: a.failed + b.failed,
+    retryableFailed: (a.retryableFailed ?? 0) + (b.retryableFailed ?? 0),
+    quarantinedFailed: (a.quarantinedFailed ?? 0) + (b.quarantinedFailed ?? 0),
+    total: a.total + b.total,
+    stuckProcessing: a.stuckProcessing + b.stuckProcessing,
+    oldestProcessingAgeMs: maxNullable(a.oldestProcessingAgeMs, b.oldestProcessingAgeMs)
+  };
+}
+function normalizeNullableAge(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : null;
+}
+function maxNullable(a, b) {
+  if (a === null) return b;
+  if (b === null) return a;
+  return Math.max(a, b);
+}
+function numberOrZero(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return 0;
+  return Math.floor(value);
+}
+
+// src/apps/server/api/health.ts
 var healthRouter = new Hono9();
 function hasEnvSignal(name) {
   const value = process.env[name];
@@ -15613,6 +15757,33 @@ function aggregateOutbox(outbox) {
   const stuckProcessing = (outbox.embedding?.stuckProcessing || 0) + (outbox.vector?.stuckProcessing || 0);
   return { pending, processing, failed, retryableFailed, quarantinedFailed, stuckProcessing };
 }
+function resolveProductivityProjectIdentity(project) {
+  if (!project || project.trim().length === 0) return { scope: "global", id: "global" };
+  const normalized = project.trim();
+  return { scope: "project", id: /^[a-f0-9]{8}$/.test(normalized) ? normalized : hashProjectPath(normalized) };
+}
+function explicitProjectStoreExists(project) {
+  if (!project || project.trim().length === 0) return true;
+  return fs12.existsSync(path14.join(resolveProjectStoragePath(project.trim()), "events.sqlite"));
+}
+function emptyProductivityStats() {
+  return { totalEvents: 0, vectorCount: 0, levelStats: [] };
+}
+function emptyProductivityQueue() {
+  return {
+    pending: 0,
+    processing: 0,
+    failed: 0,
+    retryableFailed: 0,
+    quarantinedFailed: 0,
+    total: 0,
+    stuckProcessing: 0,
+    oldestProcessingAgeMs: null
+  };
+}
+function emptyProductivityOutbox() {
+  return { embedding: emptyProductivityQueue(), vector: emptyProductivityQueue() };
+}
 healthRouter.get("/setup", async (c) => {
   const memoryService = getLightweightServiceFromQuery(c);
   try {
@@ -15669,6 +15840,40 @@ healthRouter.get("/setup", async (c) => {
     await memoryService.shutdown();
   }
 });
+healthRouter.get("/productivity", async (c) => {
+  let memoryService;
+  try {
+    const profile = parseProductivityHealthProfile(c.req.query("profile"));
+    const mode = parseProductivityHealthMode(c.req.query("mode"));
+    const projectQuery = c.req.query("project") || c.req.query("projectId");
+    const project = resolveProductivityProjectIdentity(projectQuery);
+    if (!explicitProjectStoreExists(projectQuery)) {
+      return c.json(buildProductivityHealthReport({
+        stats: emptyProductivityStats(),
+        outbox: emptyProductivityOutbox(),
+        project,
+        profile,
+        mode
+      }));
+    }
+    memoryService = getLightweightServiceFromQuery(c);
+    await memoryService.initialize();
+    const [stats, outbox] = await Promise.all([
+      memoryService.getStats(),
+      memoryService.getOutboxStats()
+    ]);
+    return c.json(buildProductivityHealthReport({ stats, outbox, project, profile, mode }));
+  } catch (error) {
+    const status = error instanceof Error && error.message.startsWith("Invalid --") ? 400 : 500;
+    return c.json({
+      status: "error",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      error: status === 400 ? "Invalid productivity health option" : "Productivity health check failed"
+    }, status);
+  } finally {
+    if (memoryService) await memoryService.shutdown();
+  }
+});
 healthRouter.get("/", async (c) => {
   const memoryService = getLightweightServiceFromQuery(c);
   try {
@@ -15990,20 +16195,20 @@ playgroundRouter.post("/dry-run", async (c) => {
 var apiRouter = new Hono11().route("/sessions", sessionsRouter).route("/events", eventsRouter).route("/search", searchRouter).route("/stats", statsRouter).route("/citations", citationsRouter).route("/turns", turnsRouter).route("/projects", projectsRouter).route("/chat", chatRouter).route("/health", healthRouter).route("/playground", playgroundRouter);
 
 // src/apps/server/index.ts
-var moduleDir = path14.dirname(fileUrlToPath(import.meta.url));
+var moduleDir = path15.dirname(fileUrlToPath(import.meta.url));
 var DASHBOARD_SESSION_COOKIE = "cml_dashboard_session";
 var DEFAULT_SESSION_MAX_AGE_SECONDS = 60 * 60 * 24 * 30;
 function resolveUiPath() {
   const candidates = [
     // Built server: dist/server/index.js -> dist/ui
-    path14.resolve(moduleDir, "../ui"),
+    path15.resolve(moduleDir, "../ui"),
     // Source/dev server: src/apps/server/index.ts -> src/apps/dashboard
-    path14.resolve(moduleDir, "../dashboard"),
+    path15.resolve(moduleDir, "../dashboard"),
     // Fallback when running from a repository root.
-    path14.resolve(process.cwd(), "dist/ui"),
-    path14.resolve(process.cwd(), "src/apps/dashboard")
+    path15.resolve(process.cwd(), "dist/ui"),
+    path15.resolve(process.cwd(), "src/apps/dashboard")
   ];
-  return candidates.find((candidate) => fs12.existsSync(path14.join(candidate, "index.html"))) ?? candidates[0];
+  return candidates.find((candidate) => fs13.existsSync(path15.join(candidate, "index.html"))) ?? candidates[0];
 }
 function normalizeDashboardHost(host = "localhost") {
   const normalized = host.trim().toLowerCase();
@@ -16231,13 +16436,13 @@ function createDashboardApp(options = {}) {
   }
   app2.route("/api", apiRouter);
   const uiPath = resolveUiPath();
-  if (fs12.existsSync(uiPath)) {
+  if (fs13.existsSync(uiPath)) {
     app2.use("/*", serveStatic({ root: uiPath }));
   }
   app2.get("*", (c) => {
-    const indexPath = path14.join(uiPath, "index.html");
-    if (fs12.existsSync(indexPath)) {
-      return c.html(fs12.readFileSync(indexPath, "utf-8"));
+    const indexPath = path15.join(uiPath, "index.html");
+    if (fs13.existsSync(indexPath)) {
+      return c.html(fs13.readFileSync(indexPath, "utf-8"));
     }
     return c.text('UI not built. Run "npm run build:ui" first.', 404);
   });