claude-memory-layer 1.0.54 → 1.0.55

package/dist/server/api/index.js

@@ -2243,12 +2243,12 @@ function resolveProjectStoragePath(projectOrHash) {
 import Database from "better-sqlite3";
 import * as fs4 from "fs";
 import * as nodePath from "path";
-function createSQLiteDatabase(path14, options) {
-  const dir = nodePath.dirname(path14);
+function createSQLiteDatabase(path15, options) {
+  const dir = nodePath.dirname(path15);
   if (!fs4.existsSync(dir)) {
     fs4.mkdirSync(dir, { recursive: true });
   }
-  const db = new Database(path14, {
+  const db = new Database(path15, {
     readonly: options?.readonly ?? false
   });
   if (!options?.readonly && (options?.walMode ?? true)) {
@@ -2711,17 +2711,17 @@ function emptyOutboxRecoveryResult() {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function getNestedRecord(root, path14) {
+function getNestedRecord(root, path15) {
   let cursor = root;
-  for (const key of path14) {
+  for (const key of path15) {
     if (!isRecord(cursor)) return void 0;
     cursor = cursor[key];
   }
   return isRecord(cursor) ? cursor : void 0;
 }
-function getNestedString(root, path14) {
+function getNestedString(root, path15) {
   let cursor = root;
-  for (const key of path14) {
+  for (const key of path15) {
     if (!isRecord(cursor)) return void 0;
     cursor = cursor[key];
   }
@@ -6684,12 +6684,12 @@ var GraphPathService = class {
         }
       }
     }
-    const paths = Array.from(bestByTarget.entries()).map(([key, path14]) => ({
+    const paths = Array.from(bestByTarget.entries()).map(([key, path15]) => ({
       target: graph.node(nodeFromKey(key)),
-      hops: path14.hops,
-      totalCost: path14.totalCost,
-      scoreContribution: path14.totalCost > 0 ? 1 / path14.totalCost : 0,
-      steps: path14.steps
+      hops: path15.hops,
+      totalCost: path15.totalCost,
+      scoreContribution: path15.totalCost > 0 ? 1 / path15.totalCost : 0,
+      steps: path15.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 };
   }
@@ -9462,12 +9462,12 @@ var Retriever = class {
         direction: "both"
       });
       const titleByEntityId = new Map(startNodes.map((node) => [node.entityId, node.title]));
-      for (const path14 of expansion.paths) {
-        if (path14.target.type !== "event") continue;
-        const target = await this.eventStore.getEvent(path14.target.id);
+      for (const path15 of expansion.paths) {
+        if (path15.target.type !== "event") continue;
+        const target = await this.eventStore.getEvent(path15.target.id);
         if (!target) continue;
-        const graphPath = toRetrievalGraphPathDebug(path14, titleByEntityId);
-        const score = graphPathScore(path14, opts.hopPenalty);
+        const graphPath = toRetrievalGraphPathDebug(path15, titleByEntityId);
+        const score = graphPathScore(path15, opts.hopPenalty);
         const existing = byId.get(target.id);
         const graphPaths = mergeGraphPaths(existing?.graphPaths ?? [], [graphPath]);
         const graphLane = {
@@ -9476,7 +9476,7 @@ var Retriever = class {
           score
         };
         const row = {
-          id: existing?.id ?? `graph-path-${path14.hops}-${target.id}`,
+          id: existing?.id ?? `graph-path-${path15.hops}-${target.id}`,
           eventId: target.id,
           content: target.content,
           score: Math.max(existing?.score ?? 0, score),
@@ -9816,8 +9816,8 @@ _Context:_ ${sessionContext}`;
   }
   matchesMetadataScope(metadata, expected) {
     if (!metadata) return false;
-    return Object.entries(expected).every(([path14, value]) => {
-      const actual = path14.split(".").reduce((acc, key) => {
+    return Object.entries(expected).every(([path15, value]) => {
+      const actual = path15.split(".").reduce((acc, key) => {
         if (typeof acc !== "object" || acc === null) return void 0;
         return acc[key];
       }, metadata);
@@ -9868,22 +9868,22 @@ function uniqueEntityStartNodes(candidates) {
   }
   return nodes;
 }
-function toRetrievalGraphPathDebug(path14, titleByEntityId) {
-  const firstStep = path14.steps[0];
+function toRetrievalGraphPathDebug(path15, titleByEntityId) {
+  const firstStep = path15.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: path14.target.id,
-    targetType: path14.target.type,
-    hops: path14.hops,
-    relationPath: path14.steps.map((step) => step.relationType)
+    targetId: path15.target.id,
+    targetType: path15.target.type,
+    hops: path15.hops,
+    relationPath: path15.steps.map((step) => step.relationType)
   };
 }
-function graphPathScore(path14, hopPenalty) {
-  const base = Math.min(0.95, Math.max(0, path14.scoreContribution));
-  return Math.max(0.05, base - hopPenalty * Math.max(0, path14.hops - 1));
+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 clampGraphHops(maxHops) {
   if (!Number.isFinite(maxHops)) return 2;
@@ -9891,14 +9891,14 @@ function clampGraphHops(maxHops) {
 }
 function mergeGraphPaths(existing, incoming) {
   const byKey = /* @__PURE__ */ new Map();
-  for (const path14 of [...existing, ...incoming]) {
-    const key = [path14.startEntityId, path14.targetType, path14.targetId, path14.hops, ...path14.relationPath].join("\0");
-    if (!byKey.has(key)) byKey.set(key, path14);
+  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);
   }
   return [...byKey.values()].sort((a, b) => a.hops - b.hops || compareStable(graphPathSignature(a), graphPathSignature(b))).slice(0, 3);
 }
-function graphPathSignature(path14) {
-  return [path14.startEntityId, path14.targetType, path14.targetId, path14.hops, ...path14.relationPath].join("|");
+function graphPathSignature(path15) {
+  return [path15.startEntityId, path15.targetType, path15.targetId, path15.hops, ...path15.relationPath].join("|");
 }
 function compareStable(a, b) {
   if (a < b) return -1;
@@ -15561,6 +15561,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];
@@ -15601,6 +15745,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 {
@@ -15657,6 +15828,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 {