@wipcomputer/memory-crystal 0.7.33 → 0.7.34-alpha.2

package/dist/cc-hook.js

@@ -26,15 +26,19 @@ import {
   openSync,
   readSync,
   closeSync,
-  copyFileSync
+  copyFileSync,
+  readdirSync
 } from "fs";
 import { join, basename } from "path";
+import { createHash } from "crypto";
 var CC_AGENT_ID = getAgentId("claude-code");
 var RELAY_URL = process.env.CRYSTAL_RELAY_URL || "";
 var RELAY_TOKEN = process.env.CRYSTAL_RELAY_TOKEN || "";
 var PRIVATE_MODE_PATH = resolveStatePath("memory-capture-state.json");
 var WATERMARK_PATH = resolveStatePath("cc-capture-watermark.json");
 var CC_ENABLED_PATH = resolveStatePath("cc-capture-enabled.json");
+var MEMORY_SYNC_WATERMARK_PATH = resolveStatePath("cc-memory-sync-watermark.json");
+var CLAUDE_PROJECTS_DIR = join(process.env.HOME || "", ".claude", "projects");
 function getCaptureMode() {
   if (RELAY_URL && RELAY_TOKEN) return "relay";
   return "local";
@@ -80,6 +84,135 @@ function saveWatermark(wm) {
   wm.lastRun = (/* @__PURE__ */ new Date()).toISOString();
   writeFileSync(writePath, JSON.stringify(wm, null, 2));
 }
+function loadMemorySyncWatermark() {
+  try {
+    if (existsSync(MEMORY_SYNC_WATERMARK_PATH)) {
+      return JSON.parse(readFileSync(MEMORY_SYNC_WATERMARK_PATH, "utf-8"));
+    }
+  } catch {
+  }
+  return { files: {}, lastRun: null };
+}
+function saveMemorySyncWatermark(wm) {
+  const writePath = stateWritePath("cc-memory-sync-watermark.json");
+  wm.lastRun = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync(writePath, JSON.stringify(wm, null, 2));
+}
+function hashFileContent(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function parseFrontmatter(content) {
+  const frontmatter = {};
+  if (!content.startsWith("---")) {
+    return { frontmatter, body: content };
+  }
+  const endIdx = content.indexOf("---", 3);
+  if (endIdx === -1) {
+    return { frontmatter, body: content };
+  }
+  const yamlBlock = content.slice(3, endIdx).trim();
+  const body = content.slice(endIdx + 3).trim();
+  for (const line of yamlBlock.split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    if (key === "name") frontmatter.name = value;
+    else if (key === "description") frontmatter.description = value;
+    else if (key === "type") frontmatter.type = value;
+  }
+  return { frontmatter, body };
+}
+var VALID_CATEGORIES = /* @__PURE__ */ new Set([
+  "fact",
+  "preference",
+  "event",
+  "opinion",
+  "skill",
+  "user",
+  "feedback",
+  "project",
+  "reference"
+]);
+function discoverMemoryFiles() {
+  const files = [];
+  try {
+    if (!existsSync(CLAUDE_PROJECTS_DIR)) return files;
+    for (const project of readdirSync(CLAUDE_PROJECTS_DIR)) {
+      const memDir = join(CLAUDE_PROJECTS_DIR, project, "memory");
+      if (!existsSync(memDir)) continue;
+      try {
+        for (const file of readdirSync(memDir)) {
+          if (!file.endsWith(".md")) continue;
+          files.push(join(memDir, file));
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+async function syncMemoryFiles() {
+  if (isPrivateMode()) return 0;
+  const files = discoverMemoryFiles();
+  if (files.length === 0) return 0;
+  const wm = loadMemorySyncWatermark();
+  const changed = [];
+  for (const filePath of files) {
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      if (content.trim().length === 0) continue;
+      const hash = hashFileContent(content);
+      if (wm.files[filePath] && wm.files[filePath].hash === hash) continue;
+      const { frontmatter, body } = parseFrontmatter(content);
+      changed.push({ path: filePath, content, hash, frontmatter, body });
+    } catch {
+    }
+  }
+  if (changed.length === 0) {
+    saveMemorySyncWatermark(wm);
+    return 0;
+  }
+  const mode = getCaptureMode();
+  if (mode === "relay") {
+    process.stderr.write(`[cc-memory-sync] skipping ${changed.length} files (relay mode not yet supported)
+`);
+    for (const item of changed) {
+      wm.files[item.path] = { hash: item.hash, syncedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    }
+    saveMemorySyncWatermark(wm);
+    return 0;
+  }
+  const config = resolveConfig();
+  const crystal = createCrystal(config);
+  await crystal.init();
+  let ingested = 0;
+  for (const item of changed) {
+    try {
+      const rawType = item.frontmatter.type || "reference";
+      const category = VALID_CATEGORIES.has(rawType) ? rawType : "reference";
+      let text = "";
+      if (item.frontmatter.name) {
+        text += `[${item.frontmatter.name}] `;
+      }
+      if (item.body.length > 0) {
+        text += item.body;
+      } else {
+        text += item.content;
+      }
+      if (text.trim().length < 10) continue;
+      await crystal.remember(text.trim(), category);
+      ingested++;
+      wm.files[item.path] = { hash: item.hash, syncedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    } catch (err) {
+      process.stderr.write(`[cc-memory-sync] error ingesting ${basename(item.path)}: ${err.message}
+`);
+    }
+  }
+  saveMemorySyncWatermark(wm);
+  return ingested;
+}
 function extractMessages(filePath, lastByteOffset) {
   const fileSize = statSync(filePath).size;
   if (lastByteOffset >= fileSize) {
@@ -356,6 +489,16 @@ async function main() {
       writeSummaryFile(paths.sessions, summary, CC_AGENT_ID, sessionId);
     } catch {
     }
+    try {
+      const syncCount = await syncMemoryFiles();
+      if (syncCount > 0) {
+        process.stderr.write(`[cc-memory-sync] ingested ${syncCount} changed memory file(s)
+`);
+      }
+    } catch (err) {
+      process.stderr.write(`[cc-memory-sync] error: ${err.message}
+`);
+    }
   } catch (err) {
     process.stderr.write(`[cc-memory-capture] error: ${err.message}
 `);

package/dist/cli.js

@@ -24,7 +24,7 @@ crystal \u2014 Sovereign memory system
 
 Commands:
   crystal search <query> [-n limit] [--agent <id>] [--since <time>] [--until <date>] [--intent <context>] [--candidates <n>] [--explain] [--provider <openai|ollama|google>]
-  crystal remember <text> [--category fact|preference|event|opinion|skill]
+  crystal remember <text> [--category fact|preference|event|opinion|skill|user|feedback|project|reference]
   crystal forget <id>
   crystal status [--provider <openai|ollama|google>]
 

package/dist/core.d.ts

@@ -48,7 +48,7 @@ interface Memory {
     id?: number;
     text: string;
     embedding?: number[];
-    category: 'fact' | 'preference' | 'event' | 'opinion' | 'skill';
+    category: 'fact' | 'preference' | 'event' | 'opinion' | 'skill' | 'user' | 'feedback' | 'project' | 'reference';
     confidence: number;
     source_ids: string;
     status: 'active' | 'deprecated' | 'deleted';

package/dist/mcp-server.js

@@ -81,7 +81,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
           text: { type: "string", description: "The fact or observation to remember" },
           category: {
             type: "string",
-            enum: ["fact", "preference", "event", "opinion", "skill"],
+            enum: ["fact", "preference", "event", "opinion", "skill", "user", "feedback", "project", "reference"],
             description: "Category of memory (default: fact)"
           }
         },

package/dist/openclaw.js

@@ -166,12 +166,13 @@ ${header}`));
 import {
   existsSync as existsSync2,
   readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2,
   readdirSync,
   copyFileSync,
   statSync,
   mkdirSync as mkdirSync2
 } from "fs";
-import { join as join2 } from "path";
+import { join as join2, basename as basename2 } from "path";
 var PRIVATE_MODE_PATH = resolveStatePath("memory-capture-state.json");
 function isPrivateMode() {
   try {
@@ -246,6 +247,90 @@ function syncDirRecursive(srcDir, destDir, ext) {
     }
   }
 }
+var WORKSPACE_WATERMARK_FILE = "workspace-memory-watermarks.json";
+function loadWatermarks() {
+  try {
+    const path = resolveStatePath(WORKSPACE_WATERMARK_FILE);
+    if (existsSync2(path)) {
+      return JSON.parse(readFileSync2(path, "utf-8"));
+    }
+  } catch {
+  }
+  return {};
+}
+function saveWatermarks(watermarks) {
+  const path = stateWritePath(WORKSPACE_WATERMARK_FILE);
+  writeFileSync2(path, JSON.stringify(watermarks, null, 2), "utf-8");
+}
+var VALID_CATEGORIES = /* @__PURE__ */ new Set([
+  "fact",
+  "preference",
+  "event",
+  "opinion",
+  "skill",
+  "user",
+  "feedback",
+  "project",
+  "reference"
+]);
+function parseFrontmatterType(content) {
+  const trimmed = content.trimStart();
+  if (!trimmed.startsWith("---")) return null;
+  const endIdx = trimmed.indexOf("---", 3);
+  if (endIdx === -1) return null;
+  const frontmatter = trimmed.slice(3, endIdx);
+  for (const line of frontmatter.split("\n")) {
+    const match = line.match(/^\s*type\s*:\s*(.+?)\s*$/);
+    if (match) {
+      const value = match[1].replace(/^["']|["']$/g, "");
+      if (VALID_CATEGORIES.has(value)) {
+        return value;
+      }
+    }
+  }
+  return null;
+}
+function collectWorkspaceMemoryFiles() {
+  const HOME2 = process.env.HOME || "";
+  const workspaceDir = join2(HOME2, ".openclaw", "workspace");
+  const files = [];
+  const memoryMd = join2(workspaceDir, "MEMORY.md");
+  if (existsSync2(memoryMd)) files.push(memoryMd);
+  const memoryDir = join2(workspaceDir, "memory");
+  if (existsSync2(memoryDir)) {
+    for (const entry of readdirSync(memoryDir)) {
+      if (entry.endsWith(".md")) {
+        files.push(join2(memoryDir, entry));
+      }
+    }
+  }
+  return files;
+}
+async function syncWorkspaceMemory(crystal, agentId, logger) {
+  const watermarks = loadWatermarks();
+  const files = collectWorkspaceMemoryFiles();
+  let ingested = 0;
+  for (const filePath of files) {
+    try {
+      const stat = statSync(filePath);
+      const lastMtime = watermarks[filePath] || 0;
+      if (stat.mtimeMs <= lastMtime) continue;
+      const content = readFileSync2(filePath, "utf-8");
+      if (!content || content.trim().length < 50) continue;
+      const category = parseFrontmatterType(content) || "fact";
+      await crystal.remember(content, category);
+      ingested++;
+      watermarks[filePath] = stat.mtimeMs;
+    } catch (err) {
+      logger.warn(`memory-crystal: workspace sync skipped ${basename2(filePath)}: ${err.message}`);
+    }
+  }
+  if (ingested > 0) {
+    saveWatermarks(watermarks);
+    logger.info(`memory-crystal: synced ${ingested} workspace memory file(s) to Crystal`);
+  }
+  return ingested;
+}
 var openclaw_default = {
   register(api) {
     const crystal = new Crystal(resolveConfig());
@@ -319,6 +404,11 @@ var openclaw_default = {
       } catch (err) {
         api.logger.error(`memory-crystal: ingest error: ${err.message}`);
       }
+      try {
+        await syncWorkspaceMemory(crystal, agentId, api.logger);
+      } catch (err) {
+        api.logger.warn(`memory-crystal: workspace memory sync failed (non-fatal): ${err.message}`);
+      }
       syncRawDataToLdm(api.logger);
     });
     function toolResult(text, isError = false) {
@@ -373,7 +463,7 @@ ${r.text}`;
           type: "object",
           properties: {
             text: { type: "string", description: "The fact to remember" },
-            category: { type: "string", enum: ["fact", "preference", "event", "opinion", "skill"] }
+            category: { type: "string", enum: ["fact", "preference", "event", "opinion", "skill", "user", "feedback", "project", "reference"] }
           },
           required: ["text"]
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wipcomputer/memory-crystal",
-  "version": "0.7.33",
+  "version": "0.7.34-alpha.2",
   "description": "Sovereign memory system — local-first with ephemeral encrypted relay. Your memory, your machine, your rules.",
   "repository": {
     "type": "git",