memory-crystal 0.2.0

package/dist/crypto.js

@@ -0,0 +1,18 @@
+import {
+  decrypt,
+  decryptJSON,
+  encrypt,
+  encryptFile,
+  encryptJSON,
+  hashBuffer,
+  loadRelayKey
+} from "./chunk-F3Y7EL7K.js";
+export {
+  decrypt,
+  decryptJSON,
+  encrypt,
+  encryptFile,
+  encryptJSON,
+  hashBuffer,
+  loadRelayKey
+};

package/dist/dev-update-SZ2Z4WCQ.js

@@ -0,0 +1,6 @@
+import {
+  runDevUpdate
+} from "./chunk-MK42FMEG.js";
+export {
+  runDevUpdate
+};

package/dist/ldm.d.ts

@@ -0,0 +1,17 @@
+declare function getAgentId(): string;
+interface LdmPaths {
+    root: string;
+    config: string;
+    crystalDb: string;
+    crystalLance: string;
+    agentRoot: string;
+    transcripts: string;
+    sessions: string;
+    daily: string;
+    journals: string;
+}
+declare function ldmPaths(agentId?: string): LdmPaths;
+declare function scaffoldLdm(agentId?: string): LdmPaths;
+declare function ensureLdm(agentId?: string): LdmPaths;
+
+export { type LdmPaths, ensureLdm, getAgentId, ldmPaths, scaffoldLdm };

package/dist/ldm.js

@@ -0,0 +1,12 @@
+import {
+  ensureLdm,
+  getAgentId,
+  ldmPaths,
+  scaffoldLdm
+} from "./chunk-PJ6FFKEX.js";
+export {
+  ensureLdm,
+  getAgentId,
+  ldmPaths,
+  scaffoldLdm
+};

package/dist/mcp-server.d.ts

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

package/dist/mcp-server.js

@@ -0,0 +1,250 @@
+#!/usr/bin/env node
+import {
+  RemoteCrystal,
+  createCrystal,
+  resolveConfig
+} from "./chunk-52QE3YI3.js";
+
+// src/mcp-server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { existsSync, readFileSync, appendFileSync, mkdirSync } from "fs";
+import { join } from "path";
+var CONFIG_DIR = join(process.env.HOME || "", ".openclaw");
+var PRIVATE_MODE_PATH = join(CONFIG_DIR, "memory", "memory-capture-state.json");
+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;
+}
+var METRICS_PATH = join(CONFIG_DIR, "memory", "search-metrics.jsonl");
+function logSearchMetric(tool, query, resultCount) {
+  try {
+    mkdirSync(join(CONFIG_DIR, "memory"), { recursive: true });
+    const entry = JSON.stringify({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      tool,
+      query,
+      results: resultCount
+    });
+    appendFileSync(METRICS_PATH, entry + "\n");
+  } catch {
+  }
+}
+var config = resolveConfig();
+var crystal = createCrystal(config);
+var isRemote = crystal instanceof RemoteCrystal;
+if (isRemote) {
+  process.stderr.write("[memory-crystal] Remote mode: " + config.remoteUrl + "\n");
+}
+var server = new Server(
+  { name: "memory-crystal", version: "0.1.0" },
+  { capabilities: { tools: {} } }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: "crystal_search",
+      description: "Search memory crystal \u2014 semantic search across all agent conversations, files, and stored memories. Returns ranked results with similarity scores.",
+      inputSchema: {
+        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 (e.g. "main", "claude-code")' }
+        },
+        required: ["query"]
+      }
+    },
+    {
+      name: "crystal_remember",
+      description: "Store a fact, preference, or observation in memory crystal. Persists across sessions and compaction.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          text: { type: "string", description: "The fact or observation to remember" },
+          category: {
+            type: "string",
+            enum: ["fact", "preference", "event", "opinion", "skill"],
+            description: "Category of memory (default: fact)"
+          }
+        },
+        required: ["text"]
+      }
+    },
+    {
+      name: "crystal_forget",
+      description: "Deprecate a memory by ID. Does not delete \u2014 marks as deprecated.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: { type: "number", description: "Memory ID to deprecate" }
+        },
+        required: ["id"]
+      }
+    },
+    {
+      name: "crystal_status",
+      description: "Show memory crystal status \u2014 chunk count, memory count, agents, embedding provider.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      }
+    },
+    {
+      name: "crystal_sources_add",
+      description: "Add a directory for source file indexing. Files are chunked, embedded, and searchable via crystal_search. Optional feature... does not affect existing memory capture.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Absolute path to the directory to index" },
+          name: { type: "string", description: 'Short name for this collection (e.g. "wipcomputer")' }
+        },
+        required: ["path", "name"]
+      }
+    },
+    {
+      name: "crystal_sources_sync",
+      description: "Sync a source collection: scan for new/changed/deleted files and re-index. Run after adding a collection or when files change.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Collection name to sync" },
+          dry_run: { type: "boolean", description: "If true, report what would change without actually indexing" }
+        },
+        required: ["name"]
+      }
+    },
+    {
+      name: "crystal_sources_status",
+      description: "Show status of all source file collections: file counts, chunk counts, last sync time.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      }
+    }
+  ]
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    await crystal.init();
+    switch (name) {
+      case "crystal_search": {
+        const query = args?.query;
+        const limit = args?.limit || 5;
+        const filter = {};
+        if (args?.agent_id) filter.agent_id = args.agent_id;
+        const results = await crystal.search(query, limit, filter);
+        logSearchMetric("crystal_search", query, results.length);
+        if (results.length === 0) {
+          return { content: [{ type: "text", text: "No results found." }] };
+        }
+        const freshnessIcon = { fresh: "\u{1F7E2}", recent: "\u{1F7E1}", aging: "\u{1F7E0}", stale: "\u{1F534}" };
+        const formatted = results.map((r, i) => {
+          const score = (r.score * 100).toFixed(1);
+          const date = r.created_at?.slice(0, 10) || "unknown";
+          const fresh = r.freshness ? `${freshnessIcon[r.freshness]} ${r.freshness}, ` : "";
+          return `[${i + 1}] (${fresh}${score}% match, ${r.agent_id}, ${date}, ${r.role})
+${r.text}`;
+        }).join("\n\n---\n\n");
+        const header = "(Recency-weighted. \u{1F7E2} fresh <3d, \u{1F7E1} recent <7d, \u{1F7E0} aging <14d, \u{1F534} stale 14d+)\n\n";
+        return { content: [{ type: "text", text: header + formatted }] };
+      }
+      case "crystal_remember": {
+        if (isPrivateMode()) {
+          return { content: [{ type: "text", text: "Private mode is on. No memories are being stored. Toggle off to resume." }] };
+        }
+        const text = args?.text;
+        const category = args?.category || "fact";
+        const id = await crystal.remember(text, category);
+        return { content: [{ type: "text", text: `Remembered (id: ${id}, category: ${category}): ${text}` }] };
+      }
+      case "crystal_forget": {
+        const id = args?.id;
+        const ok = crystal.forget(id);
+        return {
+          content: [{ type: "text", text: ok ? `Forgot memory ${id}` : `Memory ${id} not found or already deprecated` }]
+        };
+      }
+      case "crystal_status": {
+        const status = await crystal.status();
+        const text = [
+          `Memory Crystal Status${isRemote ? " (REMOTE)" : ""}`,
+          `  Data dir:   ${status.dataDir}`,
+          `  Provider:   ${status.embeddingProvider}`,
+          `  Chunks:     ${status.chunks.toLocaleString()}`,
+          `  Memories:   ${status.memories}`,
+          `  Sources:    ${status.sources}`,
+          `  Agents:     ${status.agents.length > 0 ? status.agents.join(", ") : "none yet"}`,
+          `  Sessions:   ${status.capturedSessions} captured`,
+          `  Latest:     ${status.latestCapture || "never"}`
+        ].join("\n");
+        return { content: [{ type: "text", text }] };
+      }
+      case "crystal_sources_add": {
+        if (isRemote) {
+          return { content: [{ type: "text", text: "Source indexing not available in remote mode. Index files on the Mac Mini." }] };
+        }
+        const path = args?.path;
+        const collectionName = args?.name;
+        const col = await crystal.sourcesAdd(path, collectionName);
+        return {
+          content: [{ type: "text", text: `Added collection "${col.name}" at ${col.root_path}
+Run crystal_sources_sync with name "${collectionName}" to index files.` }]
+        };
+      }
+      case "crystal_sources_sync": {
+        if (isRemote) {
+          return { content: [{ type: "text", text: "Source indexing not available in remote mode. Sync files on the Mac Mini." }] };
+        }
+        const collectionName = args?.name;
+        const dryRun = args?.dry_run;
+        const result = await crystal.sourcesSync(collectionName, { dryRun });
+        const lines = [
+          dryRun ? `Dry run for "${result.collection}":` : `Synced "${result.collection}":`,
+          `  Added:   ${result.added} files`,
+          `  Updated: ${result.updated} files`,
+          `  Removed: ${result.removed} files`,
+          `  Chunks:  ${result.chunks_added} embedded`,
+          `  Time:    ${(result.duration_ms / 1e3).toFixed(1)}s`
+        ];
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      }
+      case "crystal_sources_status": {
+        if (isRemote) {
+          return { content: [{ type: "text", text: "Source indexing not available in remote mode." }] };
+        }
+        const sourcesStatus = crystal.sourcesStatus();
+        if (sourcesStatus.collections.length === 0) {
+          return { content: [{ type: "text", text: "No source collections. Use crystal_sources_add to add a directory." }] };
+        }
+        const lines = ["Source Collections:"];
+        for (const col of sourcesStatus.collections) {
+          const syncAgo = col.last_sync_at ? `${Math.round((Date.now() - new Date(col.last_sync_at).getTime()) / 6e4)}m ago` : "never";
+          lines.push(`  ${col.name}: ${col.file_count.toLocaleString()} files, ${col.chunk_count.toLocaleString()} chunks, last sync ${syncAgo}`);
+        }
+        lines.push(`  Total: ${sourcesStatus.total_files.toLocaleString()} files, ${sourcesStatus.total_chunks.toLocaleString()} chunks`);
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      }
+      default:
+        return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
+    }
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+  }
+});
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  console.error(`MCP server failed: ${err.message}`);
+  process.exit(1);
+});

package/dist/migrate.d.ts

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

package/dist/migrate.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+import {
+  Crystal,
+  resolveConfig
+} from "./chunk-52QE3YI3.js";
+
+// src/migrate.ts
+import Database from "better-sqlite3";
+import { existsSync } from "fs";
+import { join } from "path";
+var BATCH_SIZE = 50;
+async function main() {
+  const args = process.argv.slice(2);
+  const dryRun = args.includes("--dry-run");
+  const providerFlag = args.find((_, i) => args[i - 1] === "--provider");
+  const openclawHome = process.env.OPENCLAW_HOME || join(process.env.HOME || "", ".openclaw");
+  const sourcePath = join(openclawHome, "memory", "context-embeddings.sqlite");
+  if (!existsSync(sourcePath)) {
+    console.error(`Source not found: ${sourcePath}`);
+    process.exit(1);
+  }
+  const sourceDb = new Database(sourcePath, { readonly: true });
+  sourceDb.pragma("journal_mode = WAL");
+  const total = sourceDb.prepare("SELECT COUNT(*) as count FROM conversation_chunks").get().count;
+  console.log(`Found ${total} chunks in context-embeddings.sqlite`);
+  if (dryRun) {
+    const samples = sourceDb.prepare("SELECT chunk_text, role, session_key, timestamp FROM conversation_chunks ORDER BY timestamp DESC LIMIT 5").all();
+    console.log("\nSample (5 most recent):");
+    for (const s of samples) {
+      const date = s.timestamp ? new Date(s.timestamp).toISOString().slice(0, 10) : "unknown";
+      console.log(`  [${date}] [${s.role}] ${s.chunk_text.slice(0, 80)}...`);
+    }
+    console.log(`
+Run without --dry-run to import all ${total} chunks.`);
+    sourceDb.close();
+    return;
+  }
+  const overrides = {};
+  if (providerFlag) overrides.embeddingProvider = providerFlag;
+  const config = resolveConfig(overrides);
+  const crystal = new Crystal(config);
+  await crystal.init();
+  console.log(`Embedding provider: ${config.embeddingProvider}`);
+  console.log(`Target: ${config.dataDir}`);
+  console.log(`Migrating ${total} chunks in batches of ${BATCH_SIZE}...`);
+  const rows = sourceDb.prepare(`
+    SELECT chunk_text, role, agent_id, session_key, timestamp, compaction_number
+    FROM conversation_chunks
+    ORDER BY timestamp ASC
+  `).all();
+  let imported = 0;
+  let failed = 0;
+  for (let i = 0; i < rows.length; i += BATCH_SIZE) {
+    const batch = rows.slice(i, i + BATCH_SIZE);
+    const chunks = batch.map((row) => ({
+      text: row.chunk_text,
+      role: row.role || "assistant",
+      source_type: "conversation",
+      source_id: row.session_key || "unknown",
+      agent_id: row.agent_id || "main",
+      token_count: Math.ceil((row.chunk_text?.length || 0) / 4),
+      created_at: row.timestamp ? new Date(row.timestamp).toISOString() : (/* @__PURE__ */ new Date()).toISOString()
+    }));
+    try {
+      const count = await crystal.ingest(chunks);
+      imported += count;
+      const pct = Math.round(imported / total * 100);
+      process.stdout.write(`\r  ${imported}/${total} (${pct}%)`);
+    } catch (err) {
+      failed += batch.length;
+      console.error(`
+  Batch error at ${i}: ${err.message}`);
+    }
+  }
+  console.log(`
+
+Migration complete:`);
+  console.log(`  Imported: ${imported}`);
+  console.log(`  Failed:   ${failed}`);
+  console.log(`  Provider: ${config.embeddingProvider}`);
+  const status = await crystal.status();
+  console.log(`  Total chunks in crystal: ${status.chunks}`);
+  crystal.close();
+  sourceDb.close();
+}
+main().catch((err) => {
+  console.error(`Migration failed: ${err.message}`);
+  process.exit(1);
+});

package/dist/mirror-sync.d.ts

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

package/dist/mirror-sync.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+import {
+  decrypt,
+  decryptJSON,
+  hashBuffer,
+  loadRelayKey
+} from "./chunk-F3Y7EL7K.js";
+import {
+  ldmPaths
+} from "./chunk-PJ6FFKEX.js";
+
+// src/mirror-sync.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from "fs";
+import { join, dirname } from "path";
+var HOME = process.env.HOME || "";
+var RELAY_URL = process.env.CRYSTAL_RELAY_URL || "";
+var RELAY_TOKEN = process.env.CRYSTAL_RELAY_TOKEN || "";
+var OC_DIR = join(HOME, ".openclaw");
+var _ldmPaths = ldmPaths();
+var MIRROR_DIR = join(_ldmPaths.root, "memory");
+var MIRROR_DB_PATH = _ldmPaths.crystalDb;
+var MIRROR_STATE_PATH = join(OC_DIR, "memory", "mirror-sync-state.json");
+function loadState() {
+  try {
+    if (existsSync(MIRROR_STATE_PATH)) {
+      return JSON.parse(readFileSync(MIRROR_STATE_PATH, "utf-8"));
+    }
+  } catch {
+  }
+  return { lastSync: null, lastHash: null, lastSize: null };
+}
+function saveState(state) {
+  const dir = dirname(MIRROR_STATE_PATH);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(MIRROR_STATE_PATH, JSON.stringify(state, null, 2));
+}
+async function pullMirror(force2) {
+  if (!RELAY_URL || !RELAY_TOKEN) {
+    throw new Error("CRYSTAL_RELAY_URL and CRYSTAL_RELAY_TOKEN must be set");
+  }
+  const relayKey = loadRelayKey();
+  const listResp = await fetch(`${RELAY_URL}/pickup/mirror`, {
+    headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+  });
+  if (!listResp.ok) {
+    throw new Error(`Relay list failed: ${listResp.status} ${await listResp.text()}`);
+  }
+  const listData = await listResp.json();
+  if (listData.count === 0) {
+    process.stderr.write("[mirror-sync] no mirror available\n");
+    return false;
+  }
+  const latestBlob = listData.blobs[listData.blobs.length - 1];
+  const blobResp = await fetch(`${RELAY_URL}/pickup/mirror/${latestBlob.id}`, {
+    headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+  });
+  if (!blobResp.ok) {
+    throw new Error(`Mirror fetch failed: ${blobResp.status}`);
+  }
+  const encryptedText = await blobResp.text();
+  const mirrorPayload = JSON.parse(encryptedText);
+  const meta = decryptJSON(mirrorPayload.meta, relayKey);
+  const state = loadState();
+  if (!force2 && state.lastHash === meta.hash) {
+    process.stderr.write("[mirror-sync] mirror is already up to date\n");
+    return false;
+  }
+  const dbData = decrypt(mirrorPayload.db, relayKey);
+  const actualHash = hashBuffer(dbData);
+  if (actualHash !== meta.hash) {
+    throw new Error(
+      `Mirror integrity check failed!
+  Expected: ${meta.hash}
+  Got:      ${actualHash}
+Mirror REJECTED \u2014 keeping existing local mirror.`
+    );
+  }
+  if (!existsSync(MIRROR_DIR)) mkdirSync(MIRROR_DIR, { recursive: true });
+  const tmpPath = MIRROR_DB_PATH + ".tmp";
+  writeFileSync(tmpPath, dbData);
+  if (existsSync(MIRROR_DB_PATH)) {
+    const backupPath = MIRROR_DB_PATH + ".bak";
+    try {
+      renameSync(MIRROR_DB_PATH, backupPath);
+    } catch {
+    }
+  }
+  renameSync(tmpPath, MIRROR_DB_PATH);
+  state.lastSync = (/* @__PURE__ */ new Date()).toISOString();
+  state.lastHash = meta.hash;
+  state.lastSize = dbData.length;
+  saveState(state);
+  process.stderr.write(
+    `[mirror-sync] updated: ${(dbData.length / 1024 / 1024).toFixed(1)}MB, hash=${meta.hash.slice(0, 12)}..., pushed=${meta.pushed_at}
+`
+  );
+  for (const blob of listData.blobs) {
+    try {
+      await fetch(`${RELAY_URL}/confirm/mirror/${blob.id}`, {
+        method: "DELETE",
+        headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+      });
+    } catch {
+    }
+  }
+  return true;
+}
+var args = process.argv.slice(2);
+if (args.includes("--status")) {
+  const state = loadState();
+  const hasDb = existsSync(MIRROR_DB_PATH);
+  console.log("Mirror sync status:");
+  console.log(`  Relay URL:    ${RELAY_URL || "(not set)"}`);
+  console.log(`  Local mirror: ${hasDb ? MIRROR_DB_PATH : "(none)"}`);
+  console.log(`  Last sync:    ${state.lastSync || "never"}`);
+  console.log(`  Last hash:    ${state.lastHash ? state.lastHash.slice(0, 16) + "..." : "(none)"}`);
+  console.log(`  Last size:    ${state.lastSize ? (state.lastSize / 1024 / 1024).toFixed(1) + "MB" : "(none)"}`);
+  process.exit(0);
+}
+var force = args.includes("--force");
+pullMirror(force).then((updated) => {
+  if (updated) {
+    process.stderr.write("[mirror-sync] done\n");
+  }
+  process.exit(0);
+}).catch((err) => {
+  process.stderr.write(`[mirror-sync] error: ${err.message}
+`);
+  process.exit(1);
+});

package/dist/openclaw.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    register(api: any): void;
+};
+
+export { _default as default };