@wipcomputer/memory-crystal 0.7.30 → 0.7.32

package/dist/discover.js

@@ -1,177 +0,0 @@
-// src/discover.ts
-import { existsSync, readdirSync, statSync } from "fs";
-import { join } from "path";
-var HOME = process.env.HOME || "";
-function discoverHarnesses() {
-  const found = [];
-  const ccProjectsDir = join(HOME, ".claude", "projects");
-  if (existsSync(ccProjectsDir)) {
-    let hasJsonl = false;
-    try {
-      for (const entry of readdirSync(ccProjectsDir)) {
-        const dirPath = join(ccProjectsDir, entry);
-        try {
-          if (!statSync(dirPath).isDirectory()) continue;
-          for (const file of readdirSync(dirPath)) {
-            if (file.endsWith(".jsonl") && !file.startsWith(".")) {
-              hasJsonl = true;
-              break;
-            }
-          }
-          if (hasJsonl) break;
-        } catch {
-          continue;
-        }
-      }
-    } catch {
-    }
-    if (hasJsonl) {
-      found.push({
-        platform: "claude-code",
-        sessionDir: ccProjectsDir,
-        filePattern: "*.jsonl",
-        agentIdDefault: "cc-mini"
-      });
-    }
-  }
-  const ocAgentsDir = join(HOME, ".openclaw", "agents");
-  if (existsSync(ocAgentsDir)) {
-    try {
-      for (const agentDir of readdirSync(ocAgentsDir)) {
-        const sessionsDir = join(ocAgentsDir, agentDir, "sessions");
-        if (!existsSync(sessionsDir)) continue;
-        let hasJsonl = false;
-        try {
-          for (const file of readdirSync(sessionsDir)) {
-            if (file.endsWith(".jsonl") && !file.startsWith(".")) {
-              hasJsonl = true;
-              break;
-            }
-          }
-        } catch {
-          continue;
-        }
-        if (hasJsonl) {
-          const workspaceDir = join(HOME, ".openclaw", "workspace");
-          found.push({
-            platform: "openclaw",
-            sessionDir: sessionsDir,
-            workspaceDir: existsSync(workspaceDir) ? workspaceDir : void 0,
-            filePattern: "*.jsonl",
-            agentIdDefault: `oc-lesa-mini`
-          });
-        }
-      }
-    } catch {
-    }
-  }
-  return found;
-}
-function discoverSessionFiles(harness) {
-  const files = [];
-  if (harness.platform === "claude-code") {
-    if (!existsSync(harness.sessionDir)) return files;
-    try {
-      for (const projectDir of readdirSync(harness.sessionDir)) {
-        const projectPath = join(harness.sessionDir, projectDir);
-        try {
-          if (!statSync(projectPath).isDirectory()) continue;
-        } catch {
-          continue;
-        }
-        try {
-          for (const file of readdirSync(projectPath)) {
-            if (file.endsWith(".jsonl") && !file.startsWith(".")) {
-              files.push(join(projectPath, file));
-            }
-          }
-        } catch {
-          continue;
-        }
-      }
-    } catch {
-    }
-  } else if (harness.platform === "openclaw") {
-    if (!existsSync(harness.sessionDir)) return files;
-    try {
-      for (const file of readdirSync(harness.sessionDir)) {
-        if (file.endsWith(".jsonl") && !file.startsWith(".")) {
-          files.push(join(harness.sessionDir, file));
-        }
-      }
-    } catch {
-    }
-  }
-  return files;
-}
-function discoverWorkspaceFiles(harness) {
-  if (!harness.workspaceDir || !existsSync(harness.workspaceDir)) return [];
-  const files = [];
-  walkMdFiles(harness.workspaceDir, files);
-  return files;
-}
-function walkMdFiles(dir, results) {
-  try {
-    for (const entry of readdirSync(dir)) {
-      if (entry.startsWith(".")) continue;
-      const fullPath = join(dir, entry);
-      try {
-        const stat = statSync(fullPath);
-        if (stat.isDirectory()) {
-          walkMdFiles(fullPath, results);
-        } else if (entry.endsWith(".md")) {
-          results.push(fullPath);
-        }
-      } catch {
-        continue;
-      }
-    }
-  } catch {
-  }
-}
-function discoverAll() {
-  const harnesses = discoverHarnesses();
-  const breakdown = [];
-  let totalFiles = 0;
-  let totalSizeBytes = 0;
-  for (const harness of harnesses) {
-    const sessionPaths = discoverSessionFiles(harness);
-    let sizeBytes = 0;
-    for (const filePath of sessionPaths) {
-      try {
-        sizeBytes += statSync(filePath).size;
-      } catch {
-      }
-    }
-    const workspacePaths = discoverWorkspaceFiles(harness);
-    for (const filePath of workspacePaths) {
-      try {
-        sizeBytes += statSync(filePath).size;
-      } catch {
-      }
-    }
-    const allPaths = [...sessionPaths, ...workspacePaths];
-    breakdown.push({
-      platform: harness.platform,
-      files: allPaths.length,
-      sizeBytes,
-      sessionPaths: allPaths
-    });
-    totalFiles += allPaths.length;
-    totalSizeBytes += sizeBytes;
-  }
-  return { harnesses, totalFiles, totalSizeBytes, breakdown };
-}
-function formatBytes(bytes) {
-  if (bytes < 1024) return `${bytes}B`;
-  if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)}KB`;
-  if (bytes < 1073741824) return `${(bytes / 1048576).toFixed(1)}MB`;
-  return `${(bytes / 1073741824).toFixed(1)}GB`;
-}
-export {
-  discoverAll,
-  discoverHarnesses,
-  discoverSessionFiles,
-  discoverWorkspaceFiles,
-  formatBytes
-};

package/dist/doctor.d.ts

@@ -1,9 +0,0 @@
-interface DoctorCheck {
-    name: string;
-    status: 'ok' | 'warn' | 'fail';
-    detail: string;
-    fix?: string;
-}
-declare function runDoctor(): Promise<DoctorCheck[]>;
-
-export { type DoctorCheck, runDoctor };

package/dist/doctor.js

@@ -1,334 +0,0 @@
-import {
-  detectRole
-} from "./chunk-3S6TI23B.js";
-import {
-  isBridgeInstalled,
-  isBridgeRegistered
-} from "./chunk-AEWLSYPH.js";
-import {
-  ldmPaths,
-  resolveStatePath
-} from "./chunk-EXEZZADG.js";
-
-// src/doctor.ts
-import { existsSync, readFileSync, readdirSync } from "fs";
-import { execSync } from "child_process";
-import { join } from "path";
-var HOME = process.env.HOME || "";
-async function runDoctor() {
-  const checks = [];
-  const role = detectRole();
-  const paths = ldmPaths();
-  checks.push(checkVersion());
-  checks.push({
-    name: "Role",
-    status: "ok",
-    detail: `${role.role} (${role.source})`
-  });
-  checks.push(await checkDatabase(paths.crystalDb));
-  checks.push(checkEmbeddingProvider(role.role));
-  checks.push(checkCaptureCron());
-  checks.push(checkCCHook());
-  checks.push(checkRelayConfig(role));
-  checks.push(checkMcpServer());
-  checks.push(checkBackup());
-  checks.push(checkBridge());
-  checks.push(checkLdmDirectory(paths));
-  checks.push(checkPrivateMode());
-  return checks;
-}
-function checkOpEmbeddings() {
-  const saTokenLdm = join(HOME, ".ldm", "secrets", "op-sa-token");
-  const saTokenOc = join(HOME, ".openclaw", "secrets", "op-sa-token");
-  if (!existsSync(saTokenLdm) && !existsSync(saTokenOc)) return null;
-  const saTokenPath = existsSync(saTokenLdm) ? saTokenLdm : saTokenOc;
-  try {
-    const saToken = readFileSync(saTokenPath, "utf-8").trim();
-    const result = execSync('op read "op://Agent Secrets/OpenAI API/api key" 2>/dev/null', {
-      encoding: "utf-8",
-      env: { ...process.env, OP_SERVICE_ACCOUNT_TOKEN: saToken },
-      timeout: 1e4
-    }).trim();
-    if (result) {
-      return { name: "Embeddings", status: "ok", detail: "openai (via 1Password)" };
-    }
-  } catch {
-    return {
-      name: "Embeddings",
-      status: "warn",
-      detail: "1Password SA token found but op read failed",
-      fix: "Check that op CLI is installed and SA token is valid"
-    };
-  }
-  return null;
-}
-function checkVersion() {
-  const ldmExtPkg = join(HOME, ".ldm", "extensions", "memory-crystal", "package.json");
-  const ocExtPkg = join(HOME, ".openclaw", "extensions", "memory-crystal", "package.json");
-  let installedVersion = null;
-  try {
-    if (existsSync(ldmExtPkg)) {
-      const pkg = JSON.parse(readFileSync(ldmExtPkg, "utf-8"));
-      installedVersion = pkg.version;
-    }
-  } catch {
-  }
-  if (!installedVersion) {
-    return {
-      name: "Version",
-      status: "warn",
-      detail: "not deployed to ~/.ldm/extensions/memory-crystal/",
-      fix: "crystal init"
-    };
-  }
-  let ocVersion = null;
-  try {
-    if (existsSync(ocExtPkg)) {
-      const pkg = JSON.parse(readFileSync(ocExtPkg, "utf-8"));
-      ocVersion = pkg.version;
-    }
-  } catch {
-  }
-  const locations = [`LDM v${installedVersion}`];
-  if (ocVersion) locations.push(`OC v${ocVersion}`);
-  if (ocVersion && ocVersion !== installedVersion) {
-    return {
-      name: "Version",
-      status: "warn",
-      detail: `${locations.join(", ")} (version mismatch)`,
-      fix: "crystal update"
-    };
-  }
-  return {
-    name: "Version",
-    status: "ok",
-    detail: locations.join(", ")
-  };
-}
-function checkCCHook() {
-  const settingsPath = join(HOME, ".claude", "settings.json");
-  try {
-    if (existsSync(settingsPath)) {
-      const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-      const stopHooks = settings?.hooks?.Stop;
-      if (Array.isArray(stopHooks)) {
-        const found = stopHooks.some((entry) => {
-          const hooks = entry?.hooks;
-          if (!Array.isArray(hooks)) return false;
-          return hooks.some((h) => h?.command?.includes("memory-crystal") && h?.command?.includes("cc-hook"));
-        });
-        if (found) {
-          return { name: "CC Hook", status: "ok", detail: "Stop hook configured" };
-        }
-      }
-    }
-  } catch {
-  }
-  return {
-    name: "CC Hook",
-    status: "warn",
-    detail: "Stop hook not configured in ~/.claude/settings.json",
-    fix: "crystal init"
-  };
-}
-async function checkDatabase(dbPath) {
-  if (!existsSync(dbPath)) {
-    return {
-      name: "Database",
-      status: "fail",
-      detail: "crystal.db not found",
-      fix: "crystal init"
-    };
-  }
-  try {
-    const { default: Database } = await import("better-sqlite3");
-    const db = new Database(dbPath, { readonly: true });
-    const row = db.prepare("SELECT COUNT(*) as count FROM chunks").get();
-    db.close();
-    return {
-      name: "Database",
-      status: "ok",
-      detail: `${row.count.toLocaleString()} chunks`
-    };
-  } catch (err) {
-    return {
-      name: "Database",
-      status: "warn",
-      detail: `exists but could not read: ${err.message}`
-    };
-  }
-}
-function checkEmbeddingProvider(role) {
-  const hasOpenAI = !!process.env.OPENAI_API_KEY;
-  const hasGoogle = !!process.env.GOOGLE_API_KEY && process.env.CRYSTAL_EMBEDDING_PROVIDER === "google";
-  const hasOllama = process.env.CRYSTAL_EMBEDDING_PROVIDER === "ollama";
-  if (hasOpenAI || hasGoogle || hasOllama) {
-    const provider = hasOllama ? "ollama" : hasGoogle ? "google" : "openai";
-    return {
-      name: "Embeddings",
-      status: "ok",
-      detail: provider
-    };
-  }
-  const opResult = checkOpEmbeddings();
-  if (opResult) return opResult;
-  if (role === "node") {
-    return {
-      name: "Embeddings",
-      status: "ok",
-      detail: "not needed (node mode, Core handles embeddings)"
-    };
-  }
-  return {
-    name: "Embeddings",
-    status: "fail",
-    detail: "no embedding provider configured",
-    fix: "Set OPENAI_API_KEY, or CRYSTAL_EMBEDDING_PROVIDER=ollama"
-  };
-}
-function checkCaptureCron() {
-  try {
-    const crontab = execSync("crontab -l 2>/dev/null", { encoding: "utf-8" });
-    if (crontab.includes("crystal-capture")) {
-      return { name: "Capture", status: "ok", detail: "cron installed" };
-    }
-  } catch {
-  }
-  return {
-    name: "Capture",
-    status: "warn",
-    detail: "cron not found",
-    fix: "crystal init"
-  };
-}
-function checkRelayConfig(role) {
-  if (role.role === "standalone") {
-    return { name: "Relay", status: "ok", detail: "not needed (standalone)" };
-  }
-  if (role.role === "node") {
-    if (!role.relayUrl) {
-      return { name: "Relay", status: "fail", detail: "node mode but CRYSTAL_RELAY_URL not set", fix: "Set CRYSTAL_RELAY_URL in shell profile" };
-    }
-    if (!role.relayToken) {
-      return { name: "Relay", status: "fail", detail: "node mode but CRYSTAL_RELAY_TOKEN not set", fix: "Set CRYSTAL_RELAY_TOKEN in shell profile" };
-    }
-    if (!role.relayKeyExists) {
-      return { name: "Relay", status: "fail", detail: "encryption key not found", fix: "crystal pair --code <string from Core>" };
-    }
-    return { name: "Relay", status: "ok", detail: `node -> ${role.relayUrl}` };
-  }
-  if (!role.relayKeyExists) {
-    return { name: "Relay", status: "warn", detail: "Core mode but no relay key (no nodes can sync)", fix: "crystal pair" };
-  }
-  return { name: "Relay", status: "ok", detail: "Core with relay key" };
-}
-function checkMcpServer() {
-  const candidates = [
-    join(HOME, ".claude", ".mcp.json"),
-    // user-level (legacy)
-    join(HOME, ".openclaw", ".mcp.json"),
-    // OpenClaw project-level
-    join(process.cwd(), ".mcp.json")
-    // current project
-  ];
-  for (const mcpPath of candidates) {
-    try {
-      if (existsSync(mcpPath)) {
-        const config = JSON.parse(readFileSync(mcpPath, "utf-8"));
-        if (config.mcpServers && config.mcpServers["memory-crystal"]) {
-          return { name: "MCP Server", status: "ok", detail: `memory-crystal registered (${mcpPath.replace(HOME, "~")})` };
-        }
-      }
-    } catch {
-    }
-  }
-  try {
-    const result = execSync("claude mcp get memory-crystal 2>&1", { encoding: "utf-8", timeout: 5e3 });
-    if (!result.includes("not found") && !result.includes("error")) {
-      return { name: "MCP Server", status: "ok", detail: "memory-crystal registered (user scope)" };
-    }
-  } catch {
-  }
-  return {
-    name: "MCP Server",
-    status: "warn",
-    detail: "memory-crystal not registered with Claude Code",
-    fix: "claude mcp add --scope user memory-crystal -- node ~/.ldm/extensions/memory-crystal/dist/mcp-server.js"
-  };
-}
-function checkBackup() {
-  const plistPath = join(HOME, "Library", "LaunchAgents", "ai.openclaw.ldm-backup.plist");
-  if (existsSync(plistPath)) {
-    return { name: "Backup", status: "ok", detail: "LaunchAgent installed" };
-  }
-  try {
-    const crontab = execSync("crontab -l 2>/dev/null", { encoding: "utf-8" });
-    if (crontab.includes("ldm-backup") || crontab.includes("LDMDevTools") && crontab.includes("backup")) {
-      return { name: "Backup", status: "ok", detail: "cron installed" };
-    }
-  } catch {
-  }
-  const backupsDir = join(HOME, ".ldm", "backups");
-  if (existsSync(backupsDir)) {
-    try {
-      const entries = readdirSync(backupsDir).filter((e) => !e.startsWith("."));
-      if (entries.length > 0) return { name: "Backup", status: "ok", detail: `${entries.length} backup(s) in ~/.ldm/backups/` };
-    } catch {
-    }
-  }
-  return {
-    name: "Backup",
-    status: "warn",
-    detail: "not configured",
-    fix: "crystal backup setup"
-  };
-}
-function checkBridge() {
-  const installed = isBridgeInstalled();
-  const registered = isBridgeRegistered();
-  if (installed && registered) {
-    return { name: "Bridge", status: "ok", detail: "installed and registered" };
-  }
-  if (installed && !registered) {
-    return { name: "Bridge", status: "warn", detail: "installed but not registered", fix: "crystal bridge setup" };
-  }
-  return {
-    name: "Bridge",
-    status: "warn",
-    detail: "not installed",
-    fix: "npm install -g lesa-bridge && crystal bridge setup"
-  };
-}
-function checkLdmDirectory(paths) {
-  const missing = [];
-  if (!existsSync(paths.root)) missing.push("~/.ldm");
-  if (!existsSync(join(paths.root, "memory"))) missing.push("memory/");
-  if (!existsSync(paths.state)) missing.push("state/");
-  if (!existsSync(paths.bin)) missing.push("bin/");
-  if (!existsSync(paths.transcripts)) missing.push("transcripts/");
-  if (missing.length === 0) {
-    return { name: "LDM Directory", status: "ok", detail: "intact" };
-  }
-  return {
-    name: "LDM Directory",
-    status: "fail",
-    detail: `missing: ${missing.join(", ")}`,
-    fix: "crystal init"
-  };
-}
-function checkPrivateMode() {
-  const statePath = resolveStatePath("memory-capture-state.json");
-  try {
-    if (existsSync(statePath)) {
-      const state = JSON.parse(readFileSync(statePath, "utf-8"));
-      if (state.enabled === false) {
-        return { name: "Private Mode", status: "warn", detail: "capture disabled (private mode ON)" };
-      }
-    }
-  } catch {
-  }
-  return { name: "Private Mode", status: "ok", detail: "capture enabled" };
-}
-export {
-  runDoctor
-};

package/dist/dream-weaver.d.ts

@@ -1,8 +0,0 @@
-import { DreamWeaverOptions, DreamWeaverResult } from 'dream-weaver-protocol';
-export { DreamWeaverOptions, DreamWeaverResult } from 'dream-weaver-protocol';
-
-/** Run Dream Weaver with Memory Crystal integration.
- *  Wraps the protocol engine with crystal.db embedding and crystal_remember hooks. */
-declare function runDreamWeaver(options: DreamWeaverOptions): Promise<DreamWeaverResult>;
-
-export { runDreamWeaver };

package/dist/dream-weaver.js

@@ -1,56 +0,0 @@
-import {
-  Crystal,
-  resolveConfig
-} from "./chunk-FBQWSDPC.js";
-import {
-  ldmPaths
-} from "./chunk-EXEZZADG.js";
-
-// src/dream-weaver.ts
-import {
-  runDreamWeaver as runProtocol
-} from "dream-weaver-protocol";
-async function runDreamWeaver(options) {
-  const paths = ldmPaths(options.agentId);
-  const stateDir = paths.state;
-  const resolvedOptions = {
-    ...options,
-    transcriptsDir: options.transcriptsDir || paths.transcripts,
-    outputDir: options.outputDir || paths.agentRoot
-  };
-  const hooks = {
-    async onJournalWritten(journalPath, journalText, agentId) {
-      try {
-        const config = resolveConfig();
-        const crystal = new Crystal(config);
-        await crystal.init();
-        const chunks = [{
-          text: journalText,
-          role: "assistant",
-          source_type: "journal",
-          source_id: `dream-weaver:${agentId}:${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`,
-          agent_id: agentId,
-          token_count: Math.ceil(journalText.length / 4),
-          created_at: (/* @__PURE__ */ new Date()).toISOString()
-        }];
-        await crystal.ingest(chunks);
-        if ("close" in crystal) crystal.close();
-      } catch {
-      }
-    },
-    async onMemoryExtracted(text, category) {
-      try {
-        const config = resolveConfig();
-        const crystal = new Crystal(config);
-        await crystal.init();
-        await crystal.remember(text, category);
-        if ("close" in crystal) crystal.close();
-      } catch {
-      }
-    }
-  };
-  return runProtocol(resolvedOptions, hooks, stateDir);
-}
-export {
-  runDreamWeaver
-};

package/dist/file-sync.d.ts

@@ -1,48 +0,0 @@
-interface FileManifestEntry {
-    /** Relative path from ~/.ldm/ (e.g. "agents/cc-mini/memory/daily/2026-03-05.md") */
-    path: string;
-    /** SHA-256 hex hash of file contents */
-    sha256: string;
-    /** File size in bytes */
-    size: number;
-}
-interface FileManifest {
-    version: number;
-    generatedAt: string;
-    /** Total number of files */
-    fileCount: number;
-    entries: FileManifestEntry[];
-}
-interface FileDelta {
-    /** Files to create or update on the node */
-    upsert: Array<{
-        path: string;
-        sha256: string;
-    }>;
-    /** Files to delete on the node */
-    delete: string[];
-}
-interface FileSyncState {
-    lastSync: string | null;
-    lastManifestHash: string | null;
-    filesTransferred: number;
-    filesDeleted: number;
-}
-/** Generate a manifest of all files under ~/.ldm/. */
-declare function generateManifest(): FileManifest;
-/** Compare Core manifest against local files. Returns what needs to change. */
-declare function compareManifest(coreManifest: FileManifest): FileDelta;
-declare function loadFileSyncState(): FileSyncState;
-declare function saveFileSyncState(state: FileSyncState): void;
-/** Core pushes manifest + changed files to relay "files" channel. */
-declare function pushFileSync(): Promise<{
-    manifest: number;
-    files: number;
-}>;
-/** Node pulls files from relay and applies changes. */
-declare function pullFileSync(): Promise<{
-    imported: number;
-    deleted: number;
-}>;
-
-export { type FileDelta, type FileManifest, type FileManifestEntry, type FileSyncState, compareManifest, generateManifest, loadFileSyncState, pullFileSync, pushFileSync, saveFileSyncState };

package/dist/file-sync.js

@@ -1,18 +0,0 @@
-import {
-  compareManifest,
-  generateManifest,
-  loadFileSyncState,
-  pullFileSync,
-  pushFileSync,
-  saveFileSyncState
-} from "./chunk-3G3SFYYI.js";
-import "./chunk-KCQUXVYT.js";
-import "./chunk-EXEZZADG.js";
-export {
-  compareManifest,
-  generateManifest,
-  loadFileSyncState,
-  pullFileSync,
-  pushFileSync,
-  saveFileSyncState
-};