@wipcomputer/memory-crystal 0.7.32 → 0.7.34-alpha.1

package/dist/openclaw.js

@@ -0,0 +1,434 @@
+import {
+  Crystal,
+  resolveConfig
+} from "./chunk-2GBYLMEF.js";
+import {
+  ensureLdm,
+  resolveStatePath,
+  stateWritePath
+} from "./chunk-DFQ72B7M.js";
+
+// src/dev-update.ts
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { join, basename } from "path";
+var HOME = process.env.HOME || "";
+function resolveWorkspace() {
+  const configPath = join(HOME, ".ldm", "config.json");
+  if (existsSync(configPath)) {
+    try {
+      const config = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (config.workspace) return config.workspace;
+    } catch {
+    }
+  }
+  return join(HOME, "wipcomputerinc");
+}
+var TEAM_DIR = join(resolveWorkspace(), "team");
+var CC_REPOS = join(TEAM_DIR, "cc-mini", "repos");
+var LESA_REPOS = join(TEAM_DIR, "L\u0113sa", "repos");
+var DEV_UPDATES_DIR = join(CC_REPOS, "wip-dev-updates");
+var LAST_RUN_PATH = resolveStatePath("dev-update-last-run.json");
+function loadLastRun() {
+  try {
+    if (existsSync(LAST_RUN_PATH)) {
+      return JSON.parse(readFileSync(LAST_RUN_PATH, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function saveLastRun(run) {
+  const writePath = stateWritePath("dev-update-last-run.json");
+  writeFileSync(writePath, JSON.stringify(run, null, 2));
+}
+function git(repoPath, cmd) {
+  try {
+    return execSync(`git -C "${repoPath}" ${cmd}`, {
+      encoding: "utf-8",
+      timeout: 1e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+function scanRepo(repoPath, since) {
+  if (!existsSync(join(repoPath, ".git"))) return null;
+  const name = basename(repoPath);
+  if (name === "_third-party-repos" || name === "wip-dev-updates") return null;
+  const recentCommits = git(repoPath, `log --oneline --since="${since}"`);
+  const uncommitted = git(repoPath, "status --porcelain");
+  if (!recentCommits && !uncommitted) return null;
+  const lines = [];
+  lines.push(`# ${name}`);
+  lines.push("");
+  if (recentCommits) {
+    lines.push("## Recent Commits");
+    lines.push("");
+    lines.push("```");
+    lines.push(...recentCommits.split("\n").slice(0, 10));
+    lines.push("```");
+    lines.push("");
+  }
+  if (uncommitted) {
+    lines.push("## Uncommitted Changes");
+    lines.push("");
+    lines.push("```");
+    lines.push(...uncommitted.split("\n").slice(0, 20));
+    lines.push("```");
+    lines.push("");
+  }
+  if (recentCommits) {
+    const diffStat = git(repoPath, `diff --stat "HEAD@{${since}}" HEAD`);
+    if (diffStat) {
+      lines.push("## Files Changed");
+      lines.push("");
+      lines.push("```");
+      lines.push(...diffStat.split("\n").slice(-15));
+      lines.push("```");
+      lines.push("");
+    }
+  }
+  const branch = git(repoPath, "branch --show-current") || "unknown";
+  lines.push(`**Branch:** ${branch}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function runDevUpdate(author) {
+  const lastRun = loadLastRun();
+  if (lastRun) {
+    const elapsed = Date.now() - new Date(lastRun.timestamp).getTime();
+    if (elapsed < 60 * 60 * 1e3) {
+      return { reposUpdated: 0, files: [] };
+    }
+  }
+  let since = "6 hours ago";
+  if (lastRun?.timestamp) {
+    const lastDate = new Date(lastRun.timestamp);
+    const hoursAgo = Math.ceil((Date.now() - lastDate.getTime()) / (1e3 * 60 * 60));
+    since = `${Math.max(hoursAgo, 1)} hours ago`;
+  }
+  const now = /* @__PURE__ */ new Date();
+  const ts = [
+    String(now.getMonth() + 1).padStart(2, "0"),
+    String(now.getDate()).padStart(2, "0"),
+    String(now.getFullYear())
+  ].join("-") + "--" + [
+    String(now.getHours()).padStart(2, "0"),
+    String(now.getMinutes()).padStart(2, "0"),
+    String(now.getSeconds()).padStart(2, "0")
+  ].join("-");
+  const files = [];
+  const repoDirs = [CC_REPOS, LESA_REPOS];
+  for (const parentDir of repoDirs) {
+    if (!existsSync(parentDir)) continue;
+    let entries;
+    try {
+      entries = execSync(`ls "${parentDir}"`, { encoding: "utf-8" }).trim().split("\n");
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const repoPath = join(parentDir, entry);
+      const content = scanRepo(repoPath, since);
+      if (!content) continue;
+      const repoName = basename(repoPath);
+      const outDir = join(repoPath, "ai");
+      const outFile = join(outDir, `${now.toISOString().slice(0, 10)}--${now.toISOString().slice(11, 19).replace(/:/g, "-")}--${author}--dev-update-${repoName}.md`);
+      mkdirSync(outDir, { recursive: true });
+      const header = `*Auto-generated dev update by ${author} at ${now.toISOString().slice(0, 16).replace("T", " ")}*
+
+`;
+      writeFileSync(outFile, content.replace(/^# .+\n/, `$&
+${header}`));
+      files.push(`${repoName}/ai/${basename(outFile)}`);
+    }
+  }
+  if (false) {
+    try {
+      execSync(
+        `cd "${DEV_UPDATES_DIR}" && git add -A && git commit -m "${author} auto-dev-update ${ts}: ${files.length} repo(s)" --no-verify && git push --quiet`,
+        { encoding: "utf-8", timeout: 3e4, stdio: "pipe" }
+      );
+    } catch {
+    }
+  }
+  saveLastRun({
+    timestamp: now.toISOString(),
+    author,
+    reposUpdated: files.length
+  });
+  return { reposUpdated: files.length, files };
+}
+
+// src/openclaw.ts
+import {
+  existsSync as existsSync2,
+  readFileSync as readFileSync2,
+  readdirSync,
+  copyFileSync,
+  statSync,
+  mkdirSync as mkdirSync2
+} from "fs";
+import { join as join2 } from "path";
+var PRIVATE_MODE_PATH = resolveStatePath("memory-capture-state.json");
+function isPrivateMode() {
+  try {
+    if (existsSync2(PRIVATE_MODE_PATH)) {
+      const state = JSON.parse(readFileSync2(PRIVATE_MODE_PATH, "utf-8"));
+      return state.enabled === false;
+    }
+  } catch {
+  }
+  return false;
+}
+var OC_AGENT_ID = "oc-lesa-mini";
+function syncRawDataToLdm(logger) {
+  try {
+    const paths = ensureLdm(OC_AGENT_ID);
+    const HOME2 = process.env.HOME || "";
+    const ocDir = join2(HOME2, ".openclaw");
+    const sessionsDir = join2(ocDir, "agents", "main", "sessions");
+    if (existsSync2(sessionsDir)) {
+      let copied = 0;
+      for (const file of readdirSync(sessionsDir)) {
+        if (!file.endsWith(".jsonl")) continue;
+        const src = join2(sessionsDir, file);
+        const dest = join2(paths.transcripts, file);
+        if (idempotentCopy(src, dest)) copied++;
+      }
+      if (copied > 0) logger.info(`memory-crystal: synced ${copied} session files to LDM`);
+    }
+    const workspaceDir = join2(ocDir, "workspace");
+    if (existsSync2(workspaceDir)) {
+      syncDirRecursive(workspaceDir, paths.workspace, ".md");
+    }
+    const dailyDir = join2(ocDir, "workspace", "memory");
+    if (existsSync2(dailyDir)) {
+      for (const file of readdirSync(dailyDir)) {
+        if (!file.endsWith(".md")) continue;
+        if (/^\d{4}-\d{2}-\d{2}\.md$/.test(file)) {
+          const src = join2(dailyDir, file);
+          const dest = join2(paths.daily, file);
+          idempotentCopy(src, dest);
+        }
+      }
+    }
+  } catch (err) {
+    logger.warn(`memory-crystal: raw data sync failed (non-fatal): ${err.message}`);
+  }
+}
+function idempotentCopy(src, dest) {
+  try {
+    if (existsSync2(dest)) {
+      const srcStat = statSync(src);
+      const destStat = statSync(dest);
+      if (srcStat.size === destStat.size && srcStat.mtimeMs <= destStat.mtimeMs) return false;
+    }
+    const destDir = join2(dest, "..");
+    if (!existsSync2(destDir)) mkdirSync2(destDir, { recursive: true });
+    copyFileSync(src, dest);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function syncDirRecursive(srcDir, destDir, ext) {
+  if (!existsSync2(destDir)) mkdirSync2(destDir, { recursive: true });
+  for (const entry of readdirSync(srcDir, { withFileTypes: true })) {
+    const srcPath = join2(srcDir, entry.name);
+    const destPath = join2(destDir, entry.name);
+    if (entry.isDirectory()) {
+      syncDirRecursive(srcPath, destPath, ext);
+    } else if (entry.name.endsWith(ext)) {
+      idempotentCopy(srcPath, destPath);
+    }
+  }
+}
+var openclaw_default = {
+  register(api) {
+    const crystal = new Crystal(resolveConfig());
+    let initialized = false;
+    async function ensureInit() {
+      if (!initialized) {
+        await crystal.init();
+        initialized = true;
+      }
+    }
+    api.on("agent_end", async (event, ctx) => {
+      if (isPrivateMode()) return;
+      await ensureInit();
+      const messages = event.messages;
+      if (!messages || messages.length === 0) return;
+      const agentId = ctx.agentId || OC_AGENT_ID;
+      const sessionKey = ctx.sessionKey || "unknown";
+      const state = crystal.getCaptureState(agentId, sessionKey);
+      const storedCount = state.lastMessageCount;
+      let startIndex = storedCount;
+      if (messages.length < storedCount) {
+        api.logger.info(`memory-crystal: compaction detected (${storedCount} \u2192 ${messages.length} messages), resetting capture position`);
+        startIndex = 0;
+      }
+      if (messages.length <= startIndex) return;
+      const newTurns = [];
+      for (let i = startIndex; i < messages.length; i++) {
+        const msg = messages[i];
+        if (!msg.content) continue;
+        const role = msg.role;
+        if (role !== "user" && role !== "assistant") continue;
+        let text = "";
+        if (typeof msg.content === "string") {
+          text = msg.content;
+        } else if (Array.isArray(msg.content)) {
+          text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+        }
+        if (!text || text.length < 50) continue;
+        const maxSingleChunkChars = 2e3 * 4;
+        if (text.length <= maxSingleChunkChars) {
+          newTurns.push({
+            text,
+            role,
+            source_type: "conversation",
+            source_id: sessionKey,
+            agent_id: agentId,
+            token_count: Math.ceil(text.length / 4),
+            created_at: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        } else {
+          const chunks = crystal.chunkText(text);
+          for (const chunkText of chunks) {
+            newTurns.push({
+              text: chunkText,
+              role,
+              source_type: "conversation",
+              source_id: sessionKey,
+              agent_id: agentId,
+              token_count: Math.ceil(chunkText.length / 4),
+              created_at: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        }
+      }
+      const totalTokens = newTurns.reduce((sum, c) => sum + c.token_count, 0);
+      if (totalTokens < 500) return;
+      try {
+        const count = await crystal.ingest(newTurns);
+        crystal.setCaptureState(agentId, sessionKey, messages.length, state.captureCount + 1);
+        api.logger.info(`memory-crystal: ingested ${count} chunks from ${sessionKey} (cycle ${state.captureCount + 1})`);
+      } catch (err) {
+        api.logger.error(`memory-crystal: ingest error: ${err.message}`);
+      }
+      syncRawDataToLdm(api.logger);
+    });
+    function toolResult(text, isError = false) {
+      return {
+        content: [{ type: "text", text }],
+        ...isError ? { isError: true } : {}
+      };
+    }
+    api.registerTool(
+      {
+        name: "crystal_search",
+        label: "Search Memory Crystal",
+        description: "Search memory crystal \u2014 semantic search across all conversations and stored memories.",
+        parameters: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "What to search for" },
+            limit: { type: "number", description: "Max results (default: 5)" },
+            agent_id: { type: "string", description: "Filter by agent" }
+          },
+          required: ["query"]
+        },
+        async execute(_id, params) {
+          try {
+            await ensureInit();
+            const results = await crystal.search(
+              params.query,
+              params.limit || 5,
+              params.agent_id ? { agent_id: params.agent_id } : void 0
+            );
+            if (results.length === 0) return toolResult("No results found.");
+            const formatted = results.map((r, i) => {
+              const score = (r.score * 100).toFixed(1);
+              const date = r.created_at?.slice(0, 10) || "unknown";
+              return `[${i + 1}] (${score}%, ${r.agent_id}, ${date}, ${r.role})
+${r.text}`;
+            }).join("\n\n---\n\n");
+            return toolResult(formatted);
+          } catch (err) {
+            return toolResult(`crystal_search error: ${err.message}`, true);
+          }
+        }
+      },
+      { optional: true }
+    );
+    api.registerTool(
+      {
+        name: "crystal_remember",
+        label: "Remember in Crystal",
+        description: "Store a fact, preference, or observation in memory crystal.",
+        parameters: {
+          type: "object",
+          properties: {
+            text: { type: "string", description: "The fact to remember" },
+            category: { type: "string", enum: ["fact", "preference", "event", "opinion", "skill", "user", "feedback", "project", "reference"] }
+          },
+          required: ["text"]
+        },
+        async execute(_id, params) {
+          if (isPrivateMode()) {
+            return toolResult("Private mode is on. No memories are being stored. Use /private-mode off to resume.");
+          }
+          try {
+            await ensureInit();
+            const id = await crystal.remember(params.text, params.category || "fact");
+            return toolResult(`Remembered (id: ${id}): ${params.text}`);
+          } catch (err) {
+            return toolResult(`crystal_remember error: ${err.message}`, true);
+          }
+        }
+      },
+      { optional: true }
+    );
+    api.registerTool(
+      {
+        name: "crystal_forget",
+        label: "Forget Memory",
+        description: "Deprecate a memory by ID.",
+        parameters: {
+          type: "object",
+          properties: {
+            id: { type: "number", description: "Memory ID to deprecate" }
+          },
+          required: ["id"]
+        },
+        async execute(_id, params) {
+          try {
+            await ensureInit();
+            const ok = crystal.forget(params.id);
+            return toolResult(ok ? `Forgot memory ${params.id}` : `Memory ${params.id} not found`);
+          } catch (err) {
+            return toolResult(`crystal_forget error: ${err.message}`, true);
+          }
+        }
+      },
+      { optional: true }
+    );
+    api.on("before_compaction", (_event, _ctx) => {
+      try {
+        const result = runDevUpdate("lesa");
+        if (result.reposUpdated > 0) {
+          api.logger.info(`memory-crystal: auto-dev-update wrote ${result.reposUpdated} updates before compaction`);
+        }
+      } catch (err) {
+        api.logger.warn(`memory-crystal: auto-dev-update failed: ${err.message}`);
+      }
+    });
+    api.logger.info("memory-crystal plugin registered");
+  }
+};
+export {
+  openclaw_default as default
+};

package/dist/pair.d.ts

@@ -0,0 +1,4 @@
+declare function pairShow(): Promise<void>;
+declare function pairReceive(code: string): void;
+
+export { pairReceive, pairShow };

package/dist/pair.js

@@ -0,0 +1,75 @@
+import {
+  RELAY_KEY_PATH,
+  decodePairingString,
+  encodePairingString,
+  generateRelayKey,
+  loadRelayKey
+} from "./chunk-D3MACYZ4.js";
+import "./chunk-DFQ72B7M.js";
+
+// src/pair.ts
+import { existsSync, writeFileSync, mkdirSync, chmodSync } from "fs";
+import { dirname } from "path";
+import qrcode from "qrcode-terminal";
+function generateQR(text) {
+  return new Promise((resolve) => {
+    qrcode.generate(text, { small: true }, (code) => {
+      resolve(code);
+    });
+  });
+}
+function saveKey(key) {
+  const dir = dirname(RELAY_KEY_PATH);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(RELAY_KEY_PATH, key.toString("base64") + "\n", { mode: 384 });
+  try {
+    chmodSync(RELAY_KEY_PATH, 384);
+  } catch {
+  }
+}
+async function pairShow() {
+  let key;
+  try {
+    key = loadRelayKey();
+    console.log("Relay key found.\n");
+  } catch {
+    console.log("No relay key found. Generating one...");
+    key = generateRelayKey();
+    saveKey(key);
+    console.log(`Key saved to ${RELAY_KEY_PATH}
+`);
+  }
+  const pairingString = encodePairingString(key);
+  console.log("Scan this QR code from your other device:\n");
+  const qr = await generateQR(pairingString);
+  console.log(qr);
+  console.log("Or copy this pairing code:\n");
+  console.log(`  ${pairingString}
+`);
+  console.log("On the other device, run:");
+  console.log(`  crystal pair --code ${pairingString}
+`);
+}
+function pairReceive(code) {
+  const key = decodePairingString(code);
+  if (existsSync(RELAY_KEY_PATH)) {
+    try {
+      const existing = loadRelayKey();
+      if (existing.equals(key)) {
+        console.log("This device already has the same key. Nothing to do.");
+        return;
+      }
+      console.log("Replacing existing relay key with new key from pairing code.");
+    } catch {
+    }
+  }
+  saveKey(key);
+  console.log(`Key received and saved to ${RELAY_KEY_PATH}`);
+  console.log("Relay encryption is now active on this device.");
+}
+export {
+  pairReceive,
+  pairShow
+};

package/dist/poller.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node