claude-memory-layer 1.1.1 → 1.1.2

package/dist/hooks/session-start.js

@@ -2287,12 +2287,12 @@ function getProjectStoragePath(projectPath) {
 import Database from "better-sqlite3";
 import * as fs4 from "fs";
 import * as nodePath from "path";
-function createSQLiteDatabase(path12, options) {
-  const dir = nodePath.dirname(path12);
+function createSQLiteDatabase(path13, options) {
+  const dir = nodePath.dirname(path13);
   if (!fs4.existsSync(dir)) {
     fs4.mkdirSync(dir, { recursive: true });
   }
-  const db = new Database(path12, {
+  const db = new Database(path13, {
     readonly: options?.readonly ?? false
   });
   if (!options?.readonly && (options?.walMode ?? true)) {
@@ -2948,17 +2948,17 @@ function emptyOutboxRecoveryResult() {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function getNestedRecord(root, path12) {
+function getNestedRecord(root, path13) {
   let cursor = root;
-  for (const key of path12) {
+  for (const key of path13) {
     if (!isRecord(cursor)) return void 0;
     cursor = cursor[key];
   }
   return isRecord(cursor) ? cursor : void 0;
 }
-function getNestedString(root, path12) {
+function getNestedString(root, path13) {
   let cursor = root;
-  for (const key of path12) {
+  for (const key of path13) {
     if (!isRecord(cursor)) return void 0;
     cursor = cursor[key];
   }
@@ -7355,12 +7355,12 @@ var GraphPathService = class {
         }
       }
     }
-    const paths = Array.from(bestByTarget.entries()).map(([key, path12]) => ({
+    const paths = Array.from(bestByTarget.entries()).map(([key, path13]) => ({
       target: graph.node(nodeFromKey(key)),
-      hops: path12.hops,
-      totalCost: path12.totalCost,
-      scoreContribution: path12.totalCost > 0 ? 1 / path12.totalCost : 0,
-      steps: path12.steps
+      hops: path13.hops,
+      totalCost: path13.totalCost,
+      scoreContribution: path13.totalCost > 0 ? 1 / path13.totalCost : 0,
+      steps: path13.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 };
   }
@@ -10260,12 +10260,12 @@ var Retriever = class {
         direction: "both"
       });
       const titleByEntityId = new Map(startNodes.map((node) => [node.entityId, node.title]));
-      for (const path12 of expansion.paths) {
-        if (path12.target.type !== "event") continue;
-        const target = await this.eventStore.getEvent(path12.target.id);
+      for (const path13 of expansion.paths) {
+        if (path13.target.type !== "event") continue;
+        const target = await this.eventStore.getEvent(path13.target.id);
         if (!target) continue;
-        const graphPath = toRetrievalGraphPathDebug(path12, titleByEntityId);
-        const score = graphPathScore(path12, opts.hopPenalty);
+        const graphPath = toRetrievalGraphPathDebug(path13, titleByEntityId);
+        const score = graphPathScore(path13, opts.hopPenalty);
         const existing = byId.get(target.id);
         const graphPaths = mergeGraphPaths(existing?.graphPaths ?? [], [graphPath]);
         const graphLane = {
@@ -10274,7 +10274,7 @@ var Retriever = class {
           score
         };
         const row = {
-          id: existing?.id ?? `graph-path-${path12.hops}-${target.id}`,
+          id: existing?.id ?? `graph-path-${path13.hops}-${target.id}`,
           eventId: target.id,
           content: target.content,
           score: Math.max(existing?.score ?? 0, score),
@@ -10614,8 +10614,8 @@ _Context:_ ${sessionContext}`;
   }
   matchesMetadataScope(metadata, expected) {
     if (!metadata) return false;
-    return Object.entries(expected).every(([path12, value]) => {
-      const actual = path12.split(".").reduce((acc, key) => {
+    return Object.entries(expected).every(([path13, value]) => {
+      const actual = path13.split(".").reduce((acc, key) => {
         if (typeof acc !== "object" || acc === null) return void 0;
         return acc[key];
       }, metadata);
@@ -10666,22 +10666,22 @@ function uniqueEntityStartNodes(candidates) {
   }
   return nodes;
 }
-function toRetrievalGraphPathDebug(path12, titleByEntityId) {
-  const firstStep = path12.steps[0];
+function toRetrievalGraphPathDebug(path13, titleByEntityId) {
+  const firstStep = path13.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: path12.target.id,
-    targetType: path12.target.type,
-    hops: path12.hops,
-    relationPath: path12.steps.map((step) => step.relationType)
+    targetId: path13.target.id,
+    targetType: path13.target.type,
+    hops: path13.hops,
+    relationPath: path13.steps.map((step) => step.relationType)
   };
 }
-function graphPathScore(path12, hopPenalty) {
-  const base = Math.min(0.95, Math.max(0, path12.scoreContribution));
-  return Math.max(0.05, base - hopPenalty * Math.max(0, path12.hops - 1));
+function graphPathScore(path13, hopPenalty) {
+  const base = Math.min(0.95, Math.max(0, path13.scoreContribution));
+  return Math.max(0.05, base - hopPenalty * Math.max(0, path13.hops - 1));
 }
 function clampGraphHops(maxHops) {
   if (!Number.isFinite(maxHops)) return 2;
@@ -10689,14 +10689,14 @@ function clampGraphHops(maxHops) {
 }
 function mergeGraphPaths(existing, incoming) {
   const byKey = /* @__PURE__ */ new Map();
-  for (const path12 of [...existing, ...incoming]) {
-    const key = [path12.startEntityId, path12.targetType, path12.targetId, path12.hops, ...path12.relationPath].join("\0");
-    if (!byKey.has(key)) byKey.set(key, path12);
+  for (const path13 of [...existing, ...incoming]) {
+    const key = [path13.startEntityId, path13.targetType, path13.targetId, path13.hops, ...path13.relationPath].join("\0");
+    if (!byKey.has(key)) byKey.set(key, path13);
   }
   return [...byKey.values()].sort((a, b) => a.hops - b.hops || compareStable(graphPathSignature(a), graphPathSignature(b))).slice(0, 3);
 }
-function graphPathSignature(path12) {
-  return [path12.startEntityId, path12.targetType, path12.targetId, path12.hops, ...path12.relationPath].join("|");
+function graphPathSignature(path13) {
+  return [path13.startEntityId, path13.targetType, path13.targetId, path13.hops, ...path13.relationPath].join("|");
 }
 function compareStable(a, b) {
   if (a < b) return -1;
@@ -13955,6 +13955,48 @@ function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
+// src/adapters/claude/hooks/tool-observation-vector-auto-heal-client.ts
+import { spawn as spawn2 } from "child_process";
+import * as fs10 from "fs";
+import * as path12 from "path";
+
+// src/core/operations/tool-observation-vector-auto-heal.ts
+var TOOL_OBSERVATION_VECTOR_AUTO_HEAL_KEY = "maintenance:tool_observation_vector_prune_v1";
+async function needsToolObservationVectorAutoHeal(store) {
+  const flag = await store.getEndlessConfig(TOOL_OBSERVATION_VECTOR_AUTO_HEAL_KEY);
+  return flag === null;
+}
+
+// src/adapters/claude/hooks/tool-observation-vector-auto-heal-client.ts
+function getCliScriptPath() {
+  return path12.join(path12.dirname(new URL(import.meta.url).pathname), "..", "cli", "index.js");
+}
+async function spawnToolObservationVectorAutoHealIfNeeded(projectPath) {
+  const storagePath = getProjectStoragePath(projectPath);
+  const dbPath = path12.join(storagePath, "events.sqlite");
+  if (!fs10.existsSync(dbPath)) return;
+  let store;
+  try {
+    store = new SQLiteEventStore(dbPath, { readonly: true });
+    if (!await needsToolObservationVectorAutoHeal(store)) return;
+  } catch {
+    return;
+  } finally {
+    await store?.close().catch(() => void 0);
+  }
+  const cliScriptPath = getCliScriptPath();
+  if (!fs10.existsSync(cliScriptPath)) return;
+  try {
+    const child = spawn2(
+      process.execPath,
+      [cliScriptPath, "repair", "auto-heal-tool-observation-vectors", "--project", projectPath],
+      { detached: true, stdio: "ignore", env: process.env }
+    );
+    child.unref();
+  } catch {
+  }
+}
+
 // src/adapters/claude/hooks/hook-output.ts
 function formatClaudeContextHookOutput(hookEventName, context) {
   const output = {
@@ -13980,6 +14022,8 @@ async function main() {
   registerSession(input.session_id, input.cwd);
   ensureDaemonRunning().catch(() => {
   });
+  spawnToolObservationVectorAutoHealIfNeeded(input.cwd).catch(() => {
+  });
   const memoryService = getLightweightMemoryService(input.session_id);
   try {
     if (!isHookEvaluationMode()) {