@wipcomputer/memory-crystal 0.7.32 → 0.7.33

package/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: wip-memory-crystal
 description: Search and manage the shared memory crystal. Use when user says "do you remember", "search memory", "remember this", "forget that", "memory status", "what do you know about", or needs to recall past discussions, store facts, or check what's in memory.
-version: "0.7.32"
+version: "0.7.33"
 ---
 
 # Memory Crystal

package/cloud/wrangler.toml

@@ -0,0 +1,30 @@
+name = "memory-crystal-cloud"
+main = "../src/cloud/index.ts"
+compatibility_date = "2024-12-01"
+
+# D1 — OAuth state + user accounts (Tier 1), memory storage (Tier 2)
+[[d1_databases]]
+binding = "DB"
+database_name = "memory-crystal-cloud"
+database_id = "" # Fill after: wrangler d1 create memory-crystal-cloud
+migrations_dir = "migrations"
+
+# R2 — Access the existing relay bucket for encrypted drops
+[[r2_buckets]]
+binding = "RELAY"
+bucket_name = "memory-crystal-relay"
+
+# Vectorize — Vector search for Tier 2 cloud search (enable later)
+# [[vectorize]]
+# binding = "VECTORS"
+# index_name = "memory-crystal-vectors"
+
+[vars]
+OPENAI_EMBEDDING_MODEL = "text-embedding-3-small"
+MCP_SERVER_NAME = "memory-crystal"
+MCP_SERVER_VERSION = "0.1.0"
+
+# Secrets (set via `wrangler secret put`):
+#   OPENAI_API_KEY          — for Tier 2 embedding generation
+#   CRYSTAL_RELAY_KEY       — shared encryption key (base64, 32 bytes)
+#   OAUTH_SIGNING_SECRET    — for token signing

package/dist/bridge.d.ts

@@ -0,0 +1,7 @@
+declare function isBridgeInstalled(): boolean;
+declare function isBridgeRegistered(): boolean;
+declare function isBridgeDesktopRegistered(): boolean;
+declare function registerBridgeMcp(): void;
+declare function registerBridgeDesktop(): boolean;
+
+export { isBridgeDesktopRegistered, isBridgeInstalled, isBridgeRegistered, registerBridgeDesktop, registerBridgeMcp };

package/dist/bridge.js

@@ -0,0 +1,14 @@
+import {
+  isBridgeDesktopRegistered,
+  isBridgeInstalled,
+  isBridgeRegistered,
+  registerBridgeDesktop,
+  registerBridgeMcp
+} from "./chunk-AEWLSYPH.js";
+export {
+  isBridgeDesktopRegistered,
+  isBridgeInstalled,
+  isBridgeRegistered,
+  registerBridgeDesktop,
+  registerBridgeMcp
+};

package/dist/bulk-copy.d.ts

@@ -0,0 +1,17 @@
+interface BulkCopyResult {
+    filesCopied: number;
+    filesSkipped: number;
+    bytesWritten: number;
+    durationMs: number;
+}
+interface BulkCopyOptions {
+    workspace?: boolean;
+    workspaceSrc?: string;
+}
+/** Copy session JSONL files from source locations to LDM transcripts.
+ *  sessionPaths: array of absolute paths to JSONL files.
+ *  agentId: target agent in ~/.ldm/agents/{agentId}/.
+ *  Returns copy stats. */
+declare function bulkCopyToLdm(sessionPaths: string[], agentId: string, options?: BulkCopyOptions): BulkCopyResult;
+
+export { type BulkCopyOptions, type BulkCopyResult, bulkCopyToLdm };

package/dist/bulk-copy.js

@@ -0,0 +1,90 @@
+import {
+  ldmPaths
+} from "./chunk-DFQ72B7M.js";
+
+// src/bulk-copy.ts
+import { existsSync, mkdirSync, copyFileSync, statSync, readdirSync } from "fs";
+import { join, basename } from "path";
+function bulkCopyToLdm(sessionPaths, agentId, options) {
+  const start = Date.now();
+  const paths = ldmPaths(agentId);
+  let filesCopied = 0;
+  let filesSkipped = 0;
+  let bytesWritten = 0;
+  mkdirSync(paths.transcripts, { recursive: true });
+  for (const srcPath of sessionPaths) {
+    const destPath = join(paths.transcripts, basename(srcPath));
+    if (existsSync(destPath)) {
+      try {
+        const srcSize = statSync(srcPath).size;
+        const destSize = statSync(destPath).size;
+        if (srcSize === destSize) {
+          filesSkipped++;
+          continue;
+        }
+      } catch {
+      }
+    }
+    try {
+      copyFileSync(srcPath, destPath);
+      bytesWritten += statSync(destPath).size;
+      filesCopied++;
+    } catch {
+    }
+  }
+  if (options?.workspace && options.workspaceSrc) {
+    mkdirSync(paths.workspace, { recursive: true });
+    const wsResult = copyWorkspaceRecursive(options.workspaceSrc, paths.workspace);
+    filesCopied += wsResult.copied;
+    filesSkipped += wsResult.skipped;
+    bytesWritten += wsResult.bytes;
+  }
+  return {
+    filesCopied,
+    filesSkipped,
+    bytesWritten,
+    durationMs: Date.now() - start
+  };
+}
+function copyWorkspaceRecursive(srcDir, destDir) {
+  let copied = 0;
+  let skipped = 0;
+  let bytes = 0;
+  try {
+    for (const entry of readdirSync(srcDir)) {
+      if (entry.startsWith(".")) continue;
+      const srcPath = join(srcDir, entry);
+      const destPath = join(destDir, entry);
+      try {
+        const stat = statSync(srcPath);
+        if (stat.isDirectory()) {
+          mkdirSync(destPath, { recursive: true });
+          const sub = copyWorkspaceRecursive(srcPath, destPath);
+          copied += sub.copied;
+          skipped += sub.skipped;
+          bytes += sub.bytes;
+        } else if (entry.endsWith(".md")) {
+          if (existsSync(destPath)) {
+            try {
+              if (stat.size === statSync(destPath).size) {
+                skipped++;
+                continue;
+              }
+            } catch {
+            }
+          }
+          copyFileSync(srcPath, destPath);
+          bytes += stat.size;
+          copied++;
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+  }
+  return { copied, skipped, bytes };
+}
+export {
+  bulkCopyToLdm
+};

package/dist/cc-hook.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+declare function sendCommand(command: {
+    action: string;
+    agent_id?: string;
+    mode?: string;
+}): Promise<void>;
+
+export { sendCommand };

package/dist/cc-hook.js

@@ -0,0 +1,368 @@
+#!/usr/bin/env node
+import {
+  createCrystal,
+  resolveConfig
+} from "./chunk-2GBYLMEF.js";
+import {
+  encryptJSON,
+  loadRelayKey
+} from "./chunk-D3MACYZ4.js";
+import {
+  ensureLdm,
+  getAgentId,
+  ldmPaths,
+  resolveStatePath,
+  stateWritePath
+} from "./chunk-DFQ72B7M.js";
+
+// src/cc-hook.ts
+import {
+  readFileSync,
+  writeFileSync,
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  statSync,
+  openSync,
+  readSync,
+  closeSync,
+  copyFileSync
+} from "fs";
+import { join, basename } from "path";
+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");
+function getCaptureMode() {
+  if (RELAY_URL && RELAY_TOKEN) return "relay";
+  return "local";
+}
+function isPrivateMode() {
+  try {
+    if (existsSync(PRIVATE_MODE_PATH)) {
+      const state = JSON.parse(readFileSync(PRIVATE_MODE_PATH, "utf-8"));
+      return state.enabled === false;
+    }
+  } catch {
+  }
+  return false;
+}
+function isCaptureEnabled() {
+  try {
+    if (existsSync(CC_ENABLED_PATH)) {
+      const state = JSON.parse(readFileSync(CC_ENABLED_PATH, "utf-8"));
+      return state.enabled !== false;
+    }
+  } catch {
+  }
+  return true;
+}
+function setCaptureEnabled(enabled) {
+  const writePath = stateWritePath("cc-capture-enabled.json");
+  writeFileSync(writePath, JSON.stringify({
+    enabled,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }, null, 2));
+}
+function loadWatermark() {
+  try {
+    if (existsSync(WATERMARK_PATH)) {
+      return JSON.parse(readFileSync(WATERMARK_PATH, "utf-8"));
+    }
+  } catch {
+  }
+  return { files: {}, lastRun: null };
+}
+function saveWatermark(wm) {
+  const writePath = stateWritePath("cc-capture-watermark.json");
+  wm.lastRun = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync(writePath, JSON.stringify(wm, null, 2));
+}
+function extractMessages(filePath, lastByteOffset) {
+  const fileSize = statSync(filePath).size;
+  if (lastByteOffset >= fileSize) {
+    return { messages: [], newByteOffset: fileSize };
+  }
+  const fd = openSync(filePath, "r");
+  const bufSize = fileSize - lastByteOffset;
+  const buf = Buffer.alloc(bufSize);
+  readSync(fd, buf, 0, bufSize, lastByteOffset);
+  closeSync(fd);
+  const lines = buf.toString("utf-8").split("\n").filter(Boolean);
+  const messages = [];
+  for (const line of lines) {
+    try {
+      const obj = JSON.parse(line);
+      if (obj.type !== "user" && obj.type !== "assistant") continue;
+      const msg = obj.message;
+      if (!msg) continue;
+      let text = "";
+      if (typeof msg.content === "string") {
+        text = msg.content;
+      } else if (Array.isArray(msg.content)) {
+        const parts = [];
+        for (const block of msg.content) {
+          if (block.type === "text" && block.text) parts.push(block.text);
+          if (block.type === "thinking" && block.thinking) parts.push(`[thinking] ${block.thinking}`);
+        }
+        text = parts.join("\n\n");
+      }
+      if (text.length < 20) continue;
+      messages.push({
+        role: msg.role || obj.type,
+        text,
+        timestamp: obj.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId: obj.sessionId || "unknown"
+      });
+    } catch {
+    }
+  }
+  return { messages, newByteOffset: fileSize };
+}
+function archiveTranscript(transcriptPath, agentId) {
+  try {
+    if (isPrivateMode()) return;
+    const paths = ensureLdm(agentId);
+    const dest = join(paths.transcripts, basename(transcriptPath));
+    if (existsSync(dest)) {
+      const srcMtime = statSync(transcriptPath).mtimeMs;
+      const dstMtime = statSync(dest).mtimeMs;
+      if (srcMtime <= dstMtime) return;
+    }
+    copyFileSync(transcriptPath, dest);
+  } catch {
+  }
+}
+function appendDailyLog(messages, agentId) {
+  try {
+    const paths = ldmPaths(agentId);
+    if (!existsSync(paths.root)) return;
+    if (!existsSync(paths.daily)) mkdirSync(paths.daily, { recursive: true });
+    const now = /* @__PURE__ */ new Date();
+    const dateStr = now.toISOString().slice(0, 10);
+    const timeStr = now.toLocaleTimeString("en-US", {
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: false,
+      timeZone: "America/Los_Angeles"
+    });
+    const logPath = join(paths.daily, `${dateStr}.md`);
+    const userMsg = messages.find((m) => m.role === "user");
+    if (!userMsg) return;
+    const snippet = userMsg.text.slice(0, 120).replace(/\n/g, " ").trim();
+    const line = `- **${timeStr}** ${snippet}${userMsg.text.length > 120 ? "..." : ""}
+`;
+    if (!existsSync(logPath)) {
+      writeFileSync(logPath, `# ${dateStr} - CC Daily Log
+
+`);
+    }
+    appendFileSync(logPath, line);
+  } catch {
+  }
+}
+async function dropAtRelay(messages) {
+  const relayKey = loadRelayKey();
+  const payload = {
+    agent_id: CC_AGENT_ID,
+    dropped_at: (/* @__PURE__ */ new Date()).toISOString(),
+    messages: messages.map((m) => ({
+      text: m.text,
+      role: m.role,
+      timestamp: m.timestamp,
+      sessionId: m.sessionId
+    }))
+  };
+  const encrypted = encryptJSON(payload, relayKey);
+  const body = JSON.stringify(encrypted);
+  let retries = 0;
+  while (retries < 4) {
+    try {
+      const resp = await fetch(`${RELAY_URL}/drop/conversations`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${RELAY_TOKEN}`,
+          "Content-Type": "application/octet-stream"
+        },
+        body
+      });
+      if (!resp.ok) {
+        const err = await resp.text();
+        throw new Error(`Relay drop failed: ${resp.status} ${err}`);
+      }
+      const result = await resp.json();
+      return messages.length;
+    } catch (err) {
+      retries++;
+      if (retries >= 4) throw err;
+      const delay = Math.min(1e3 * 2 ** retries, 3e4);
+      process.stderr.write(`  [relay retry ${retries}] ${err.message}, waiting ${delay}ms
+`);
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  return 0;
+}
+async function sendCommand(command) {
+  if (!RELAY_URL || !RELAY_TOKEN) {
+    throw new Error("Relay not configured. Set CRYSTAL_RELAY_URL and CRYSTAL_RELAY_TOKEN.");
+  }
+  const relayKey = loadRelayKey();
+  const payload = {
+    ...command,
+    from_agent: CC_AGENT_ID,
+    sent_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const encrypted = encryptJSON(payload, relayKey);
+  const body = JSON.stringify(encrypted);
+  const resp = await fetch(`${RELAY_URL}/drop/commands`, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${RELAY_TOKEN}`,
+      "Content-Type": "application/octet-stream"
+    },
+    body
+  });
+  if (!resp.ok) {
+    throw new Error(`Command relay failed: ${resp.status} ${await resp.text()}`);
+  }
+}
+var BATCH_SIZE = 200;
+async function ingestLocal(messages) {
+  const config = resolveConfig();
+  const crystal = createCrystal(config);
+  await crystal.init();
+  const maxSingleChunkChars = 2e3 * 4;
+  const chunks = [];
+  for (const msg of messages) {
+    if (msg.text.length <= maxSingleChunkChars) {
+      chunks.push({
+        text: msg.text,
+        role: msg.role,
+        source_type: "conversation",
+        source_id: `cc:${msg.sessionId}`,
+        agent_id: CC_AGENT_ID,
+        token_count: Math.ceil(msg.text.length / 4),
+        created_at: msg.timestamp
+      });
+    } else {
+      for (const ct of crystal.chunkText(msg.text)) {
+        chunks.push({
+          text: ct,
+          role: msg.role,
+          source_type: "conversation",
+          source_id: `cc:${msg.sessionId}`,
+          agent_id: CC_AGENT_ID,
+          token_count: Math.ceil(ct.length / 4),
+          created_at: msg.timestamp
+        });
+      }
+    }
+  }
+  let total = 0;
+  for (let i = 0; i < chunks.length; i += BATCH_SIZE) {
+    const batch = chunks.slice(i, i + BATCH_SIZE);
+    let retries = 0;
+    while (retries < 4) {
+      try {
+        total += await crystal.ingest(batch);
+        break;
+      } catch (err) {
+        retries++;
+        if (retries >= 4) throw err;
+        const delay = Math.min(1e3 * 2 ** retries, 3e4);
+        process.stderr.write(`  [retry ${retries}] ${err.message}, waiting ${delay}ms
+`);
+        await new Promise((r) => setTimeout(r, delay));
+      }
+    }
+  }
+  return total;
+}
+var args = process.argv.slice(2);
+if (args.includes("--on")) {
+  setCaptureEnabled(true);
+  console.log("(*) Claude Code memory capture ON");
+  process.exit(0);
+}
+if (args.includes("--off")) {
+  setCaptureEnabled(false);
+  console.log("( ) Claude Code memory capture OFF");
+  process.exit(0);
+}
+if (args.includes("--status")) {
+  const mode = getCaptureMode();
+  console.log(isCaptureEnabled() ? "(*) CC capture: ON" : "( ) CC capture: OFF");
+  console.log(isPrivateMode() ? "( ) Private mode: ON (blocks all capture)" : "(*) Private mode: OFF");
+  console.log(`    Mode: ${mode}${mode === "relay" ? ` (${RELAY_URL})` : ""}`);
+  console.log(`    Agent ID: ${CC_AGENT_ID}`);
+  process.exit(0);
+}
+async function main() {
+  let input = "";
+  for await (const chunk of process.stdin) {
+    input += chunk;
+  }
+  let hookData;
+  try {
+    hookData = JSON.parse(input);
+  } catch {
+    process.exit(0);
+  }
+  const transcriptPath = hookData.transcript_path;
+  if (!transcriptPath || !existsSync(transcriptPath)) process.exit(0);
+  if (isPrivateMode() || !isCaptureEnabled()) process.exit(0);
+  archiveTranscript(transcriptPath);
+  const wm = loadWatermark();
+  const fileKey = transcriptPath;
+  if (!wm.files[fileKey]) {
+    wm.files[fileKey] = { lastByteOffset: 0, lastTimestamp: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  const lastOffset = wm.files[fileKey].lastByteOffset || 0;
+  const { messages, newByteOffset } = extractMessages(transcriptPath, lastOffset);
+  if (messages.length === 0) {
+    wm.files[fileKey] = { lastByteOffset: newByteOffset, lastTimestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    saveWatermark(wm);
+    process.exit(0);
+  }
+  const totalTokens = messages.reduce((sum, m) => sum + Math.ceil(m.text.length / 4), 0);
+  if (totalTokens < 100) {
+    wm.files[fileKey] = { lastByteOffset: newByteOffset, lastTimestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    saveWatermark(wm);
+    process.exit(0);
+  }
+  const mode = getCaptureMode();
+  try {
+    if (mode === "relay") {
+      const count = await dropAtRelay(messages);
+      process.stderr.write(`[cc-memory-capture] relayed ${count} messages (${totalTokens} tokens) from ${basename(transcriptPath)}
+`);
+    } else {
+      const count = await ingestLocal(messages);
+      process.stderr.write(`[cc-memory-capture] ${count} chunks (${totalTokens} tokens) from ${basename(transcriptPath)}
+`);
+    }
+    wm.files[fileKey] = { lastByteOffset: newByteOffset, lastTimestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    saveWatermark(wm);
+    appendDailyLog(messages);
+    try {
+      const { generateSessionSummary, writeSummaryFile } = await import("./summarize.js");
+      const paths = ldmPaths();
+      const summaryMsgs = messages.map((m) => ({ role: m.role, text: m.text, timestamp: m.timestamp, sessionId: m.sessionId }));
+      const summary = await generateSessionSummary(summaryMsgs);
+      const sessionId = messages[0]?.sessionId || "unknown";
+      writeSummaryFile(paths.sessions, summary, CC_AGENT_ID, sessionId);
+    } catch {
+    }
+  } catch (err) {
+    process.stderr.write(`[cc-memory-capture] error: ${err.message}
+`);
+    process.exit(1);
+  }
+}
+main();
+export {
+  sendCommand
+};

package/dist/cc-poller.d.ts

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