claude-memory-layer 1.0.17 → 1.0.19

package/dist/hooks/user-prompt-submit.js

@@ -8,6 +8,9 @@ const __dirname = dirname(__filename);
 
 // src/hooks/user-prompt-submit.ts
 import { randomUUID as randomUUID9 } from "crypto";
+import * as fs6 from "fs";
+import * as path5 from "path";
+import * as os3 from "os";
 
 // src/services/memory-service.ts
 import * as path3 from "path";
@@ -70,11 +73,11 @@ function toDate(value) {
     return new Date(value);
   return new Date(String(value));
 }
-function createDatabase(path5, options) {
+function createDatabase(path6, options) {
   if (options?.readOnly) {
-    return new duckdb.Database(path5, { access_mode: "READ_ONLY" });
+    return new duckdb.Database(path6, { access_mode: "READ_ONLY" });
   }
-  return new duckdb.Database(path5);
+  return new duckdb.Database(path6);
 }
 function dbRun(db, sql, params = []) {
   return new Promise((resolve2, reject) => {
@@ -758,12 +761,12 @@ import { randomUUID as randomUUID2 } from "crypto";
 import Database from "better-sqlite3";
 import * as fs from "fs";
 import * as nodePath from "path";
-function createSQLiteDatabase(path5, options) {
-  const dir = nodePath.dirname(path5);
+function createSQLiteDatabase(path6, options) {
+  const dir = nodePath.dirname(path6);
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
-  const db = new Database(path5, {
+  const db = new Database(path6, {
     readonly: options?.readonly ?? false
   });
   if (!options?.readonly && (options?.walMode ?? true)) {
@@ -3439,8 +3442,8 @@ _Context:_ ${sessionContext}`;
   matchesMetadataScope(metadata, expected) {
     if (!metadata)
       return false;
-    return Object.entries(expected).every(([path5, value]) => {
-      const actual = path5.split(".").reduce((acc, key) => {
+    return Object.entries(expected).every(([path6, value]) => {
+      const actual = path6.split(".").reduce((acc, key) => {
         if (typeof acc !== "object" || acc === null)
           return void 0;
         return acc[key];
@@ -6881,6 +6884,12 @@ var MemoryService = class {
   recordMemoryAccess(eventId, sessionId, confidence = 1) {
     this.graduation.recordAccess(eventId, sessionId, confidence);
   }
+  /**
+   * Backward-compatible alias used by some hooks
+   */
+  async close() {
+    await this.shutdown();
+  }
   /**
    * Shutdown service
    */
@@ -6916,6 +6925,42 @@ var MemoryService = class {
   }
 };
 var serviceCache = /* @__PURE__ */ new Map();
+var GLOBAL_KEY = "__global__";
+function getDefaultMemoryService() {
+  if (!serviceCache.has(GLOBAL_KEY)) {
+    serviceCache.set(GLOBAL_KEY, new MemoryService({
+      storagePath: "~/.claude-code/memory",
+      analyticsEnabled: false,
+      // Hooks don't need DuckDB
+      sharedStoreConfig: { enabled: false }
+      // Shared store uses DuckDB too
+    }));
+  }
+  return serviceCache.get(GLOBAL_KEY);
+}
+function getMemoryServiceForProject(projectPath, sharedStoreConfig) {
+  const hash = hashProjectPath(projectPath);
+  if (!serviceCache.has(hash)) {
+    const storagePath = getProjectStoragePath(projectPath);
+    serviceCache.set(hash, new MemoryService({
+      storagePath,
+      projectHash: hash,
+      projectPath,
+      // Override shared store config - hooks don't need DuckDB
+      sharedStoreConfig: sharedStoreConfig ?? { enabled: false },
+      analyticsEnabled: false
+      // Hooks don't need DuckDB
+    }));
+  }
+  return serviceCache.get(hash);
+}
+function getMemoryServiceForSession(sessionId) {
+  const projectInfo = getSessionProject(sessionId);
+  if (projectInfo) {
+    return getMemoryServiceForProject(projectInfo.projectPath);
+  }
+  return getDefaultMemoryService();
+}
 function getLightweightMemoryService(sessionId) {
   const projectInfo = getSessionProject(sessionId);
   const key = projectInfo ? `lightweight_${projectInfo.projectHash}` : "lightweight_global";
@@ -6968,6 +7013,10 @@ var MAX_MEMORIES = parseInt(process.env.CLAUDE_MEMORY_MAX_COUNT || "5");
 var BASE_MIN_SCORE = parseFloat(process.env.CLAUDE_MEMORY_MIN_SCORE || "0.4");
 var FALLBACK_MIN_SCORE = parseFloat(process.env.CLAUDE_MEMORY_FALLBACK_MIN_SCORE || "0.3");
 var ENABLE_SEARCH = process.env.CLAUDE_MEMORY_SEARCH !== "false";
+var RETRIEVAL_MODE = process.env.CLAUDE_MEMORY_RETRIEVAL_MODE || "hybrid";
+var SEMANTIC_TIMEOUT_MS = parseInt(process.env.CLAUDE_MEMORY_SEMANTIC_TIMEOUT_MS || "1200");
+var ADHERENCE_INTERVAL_TURNS = parseInt(process.env.CLAUDE_MEMORY_ADHERENCE_INTERVAL_TURNS || "3");
+var ADHERENCE_STATE_DIR = path5.join(os3.homedir(), ".claude-code", "memory");
 function shouldStorePrompt(prompt) {
   const trimmed = prompt.trim();
   if (trimmed.startsWith("/"))
@@ -6986,6 +7035,113 @@ function getDynamicMinScore(prompt) {
     return Math.max(0.3, BASE_MIN_SCORE - 0.05);
   return BASE_MIN_SCORE;
 }
+function withTimeout(promise, timeoutMs) {
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => reject(new Error(`semantic retrieval timeout (${timeoutMs}ms)`)), timeoutMs);
+    promise.then((result) => {
+      clearTimeout(timer);
+      resolve2(result);
+    }).catch((error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+function formatMemoryContext(items) {
+  if (items.length === 0)
+    return "";
+  const lines = items.map((m) => {
+    const preview = m.content.length > 300 ? m.content.substring(0, 300) + "..." : m.content;
+    return `- [${m.type}] ${preview}`;
+  });
+  return `\u{1F4A1} **Related memories found:**
+
+${lines.join("\n\n")}`;
+}
+function getAdherenceStatePath(sessionId) {
+  return path5.join(ADHERENCE_STATE_DIR, `.adherence-state-${sessionId}.json`);
+}
+function readAdherenceState(sessionId) {
+  try {
+    const filePath = getAdherenceStatePath(sessionId);
+    if (!fs6.existsSync(filePath)) {
+      return {
+        sessionId,
+        turnCount: 0,
+        lastCheckedTurn: 0,
+        lastPrompt: "",
+        lastReason: "init",
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    const data = fs6.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(data);
+    if (parsed.sessionId !== sessionId)
+      throw new Error("session mismatch");
+    return parsed;
+  } catch {
+    return {
+      sessionId,
+      turnCount: 0,
+      lastCheckedTurn: 0,
+      lastPrompt: "",
+      lastReason: "init",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+}
+function writeAdherenceState(state) {
+  try {
+    if (!fs6.existsSync(ADHERENCE_STATE_DIR)) {
+      fs6.mkdirSync(ADHERENCE_STATE_DIR, { recursive: true });
+    }
+    const filePath = getAdherenceStatePath(state.sessionId);
+    const tempPath = filePath + ".tmp";
+    fs6.writeFileSync(tempPath, JSON.stringify(state));
+    fs6.renameSync(tempPath, filePath);
+  } catch {
+  }
+}
+function hasWriteIntent(prompt) {
+  return /(fix|refactor|implement|change|modify|edit|update|rewrite|patch|create|add|remove|delete|버그|수정|리팩터|구현|추가|삭제|개선)/i.test(prompt);
+}
+function tokenize(text) {
+  const stopwords = /* @__PURE__ */ new Set(["the", "and", "for", "with", "that", "this", "from", "have", "what", "when", "where", "how", "why", "\uADF8\uB9AC\uACE0", "\uADF8\uB9AC\uACE0\uC694", "\uC774\uAC70", "\uADF8\uAC70", "\uD574\uC8FC\uC138\uC694", "\uD574\uC918", "\uC880", "\uC5D0\uC11C", "\uC73C\uB85C", "\uD558\uB294", "\uD574"]);
+  return text.toLowerCase().replace(/[^a-z0-9가-힣\s]/g, " ").split(/\s+/).filter((w) => w.length >= 2 && !stopwords.has(w));
+}
+function isTopicShift(currentPrompt, lastPrompt) {
+  if (!lastPrompt || lastPrompt.length < 10)
+    return false;
+  const a = new Set(tokenize(currentPrompt));
+  const b = new Set(tokenize(lastPrompt));
+  if (a.size === 0 || b.size === 0)
+    return false;
+  let intersection = 0;
+  for (const token of a) {
+    if (b.has(token))
+      intersection++;
+  }
+  const union = a.size + b.size - intersection;
+  const similarity = union > 0 ? intersection / union : 0;
+  return similarity < 0.2;
+}
+function shouldRunAdherenceCheck(turnCount, prompt, state) {
+  if (turnCount === 1)
+    return { run: true, reason: "first-turn" };
+  if (hasWriteIntent(prompt))
+    return { run: true, reason: "write-intent" };
+  if (isTopicShift(prompt, state.lastPrompt))
+    return { run: true, reason: "topic-shift" };
+  if (turnCount - state.lastCheckedTurn >= ADHERENCE_INTERVAL_TURNS)
+    return { run: true, reason: "interval" };
+  return { run: false, reason: "skip" };
+}
+function logAdherenceDecision(sessionId, turn, run, reason) {
+  if (!process.env.CLAUDE_MEMORY_DEBUG)
+    return;
+  const mode = run ? "enforced" : "skipped";
+  console.error(`[adherence] session=${sessionId} turn=${turn} mode=${mode} reason=${reason}`);
+}
 async function main() {
   const inputData = await readStdin();
   const input = JSON.parse(inputData);
@@ -6993,49 +7149,107 @@ async function main() {
   writeTurnState(input.session_id, turnId);
   const memoryService = getLightweightMemoryService(input.session_id);
   try {
+    let context = "";
+    const adherenceState = readAdherenceState(input.session_id);
+    const currentTurn = adherenceState.turnCount + 1;
+    const adherenceDecision = shouldRunAdherenceCheck(currentTurn, input.prompt, adherenceState);
+    logAdherenceDecision(input.session_id, currentTurn, adherenceDecision.run, adherenceDecision.reason);
     if (shouldStorePrompt(input.prompt)) {
       await memoryService.storeUserPrompt(
         input.session_id,
         input.prompt,
-        { turnId }
+        {
+          turnId,
+          adherence: {
+            checked: adherenceDecision.run,
+            reason: adherenceDecision.reason,
+            turn: currentTurn
+          }
+        }
       );
     }
-    let context = "";
-    if (ENABLE_SEARCH && input.prompt.length > 10) {
+    if (ENABLE_SEARCH && input.prompt.length > 10 && adherenceDecision.run) {
       const minScore = getDynamicMinScore(input.prompt);
-      let results = await memoryService.keywordSearch(input.prompt, {
-        topK: MAX_MEMORIES,
-        minScore
-      });
-      if (results.length === 0 && FALLBACK_MIN_SCORE < minScore) {
-        results = await memoryService.keywordSearch(input.prompt, {
+      let mergedMemories = [];
+      const canUseSemantic = RETRIEVAL_MODE === "semantic" || RETRIEVAL_MODE === "hybrid";
+      if (canUseSemantic) {
+        try {
+          const semanticService = getMemoryServiceForSession(input.session_id);
+          const semantic = await withTimeout(
+            semanticService.retrieveMemories(input.prompt, {
+              topK: MAX_MEMORIES,
+              minScore,
+              sessionId: input.session_id,
+              intentRewrite: true,
+              adaptiveRerank: true,
+              projectScopeMode: "strict"
+            }),
+            SEMANTIC_TIMEOUT_MS
+          );
+          mergedMemories = semantic.memories.map((m) => ({
+            type: m.event.eventType,
+            content: m.event.content,
+            id: m.event.id,
+            score: m.score
+          }));
+        } catch {
+        }
+      }
+      const shouldUseKeywordFallback = RETRIEVAL_MODE === "keyword" || RETRIEVAL_MODE === "hybrid" || mergedMemories.length === 0;
+      if (shouldUseKeywordFallback && mergedMemories.length < MAX_MEMORIES) {
+        let results = await memoryService.keywordSearch(input.prompt, {
           topK: MAX_MEMORIES,
-          minScore: FALLBACK_MIN_SCORE
+          minScore
         });
-      }
-      if (results.length > 0) {
-        const eventIds = results.map((r) => r.event.id);
-        await memoryService.incrementMemoryAccess(eventIds);
+        if (results.length === 0 && FALLBACK_MIN_SCORE < minScore) {
+          results = await memoryService.keywordSearch(input.prompt, {
+            topK: MAX_MEMORIES,
+            minScore: FALLBACK_MIN_SCORE
+          });
+        }
+        const existingIds = new Set(mergedMemories.map((m) => m.id).filter(Boolean));
         for (const r of results) {
+          if (existingIds.has(r.event.id))
+            continue;
+          mergedMemories.push({
+            type: r.event.eventType,
+            content: r.event.content,
+            id: r.event.id,
+            score: r.score
+          });
+          if (mergedMemories.length >= MAX_MEMORIES)
+            break;
+        }
+      }
+      if (mergedMemories.length > 0) {
+        const eventIds = mergedMemories.map((m) => m.id).filter((v) => Boolean(v));
+        if (eventIds.length > 0) {
+          await memoryService.incrementMemoryAccess(eventIds);
+        }
+        for (const m of mergedMemories) {
+          if (!m.id)
+            continue;
           try {
             await memoryService.recordRetrieval(
-              r.event.id,
+              m.id,
               input.session_id,
-              r.score,
+              m.score ?? minScore,
               input.prompt
             );
           } catch {
           }
         }
-        const memories = results.map((r) => {
-          const preview = r.event.content.length > 300 ? r.event.content.substring(0, 300) + "..." : r.event.content;
-          return `- [${r.event.eventType}] ${preview}`;
-        });
-        context = `\u{1F4A1} **Related memories found:**
-
-${memories.join("\n\n")}`;
+        context = formatMemoryContext(mergedMemories);
       }
     }
+    writeAdherenceState({
+      sessionId: input.session_id,
+      turnCount: currentTurn,
+      lastCheckedTurn: adherenceDecision.run ? currentTurn : adherenceState.lastCheckedTurn,
+      lastPrompt: input.prompt,
+      lastReason: adherenceDecision.reason,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
     const output = { context };
     console.log(JSON.stringify(output));
   } catch (error) {