@wipcomputer/memory-crystal 0.7.32 → 0.7.33

package/dist/chunk-YX6AXLVK.js

@@ -0,0 +1,159 @@
+// src/ldm.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync, chmodSync } from "fs";
+import { join, dirname } from "path";
+import { execSync } from "child_process";
+import { fileURLToPath } from "url";
+var HOME = process.env.HOME || "";
+var LDM_ROOT = join(HOME, ".ldm");
+function getAgentId() {
+  return process.env.CRYSTAL_AGENT_ID || "cc-mini";
+}
+function ldmPaths(agentId) {
+  const id = agentId || getAgentId();
+  const agentRoot = join(LDM_ROOT, "agents", id);
+  return {
+    root: LDM_ROOT,
+    bin: join(LDM_ROOT, "bin"),
+    secrets: join(LDM_ROOT, "secrets"),
+    state: join(LDM_ROOT, "state"),
+    config: join(LDM_ROOT, "config.json"),
+    crystalDb: join(LDM_ROOT, "memory", "crystal.db"),
+    crystalLance: join(LDM_ROOT, "memory", "lance"),
+    agentRoot,
+    transcripts: join(agentRoot, "memory", "transcripts"),
+    sessions: join(agentRoot, "memory", "sessions"),
+    daily: join(agentRoot, "memory", "daily"),
+    journals: join(agentRoot, "memory", "journals")
+  };
+}
+function loadConfig() {
+  const configPath = join(LDM_ROOT, "config.json");
+  try {
+    if (existsSync(configPath)) {
+      return JSON.parse(readFileSync(configPath, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function saveConfig(config) {
+  const configPath = join(LDM_ROOT, "config.json");
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+function scaffoldLdm(agentId) {
+  const paths = ldmPaths(agentId);
+  mkdirSync(join(paths.root, "memory"), { recursive: true });
+  mkdirSync(paths.crystalLance, { recursive: true });
+  mkdirSync(paths.bin, { recursive: true });
+  mkdirSync(paths.secrets, { recursive: true, mode: 448 });
+  mkdirSync(paths.state, { recursive: true });
+  mkdirSync(paths.transcripts, { recursive: true });
+  mkdirSync(paths.sessions, { recursive: true });
+  mkdirSync(paths.daily, { recursive: true });
+  mkdirSync(paths.journals, { recursive: true });
+  const id = agentId || getAgentId();
+  let config = loadConfig();
+  if (!config) {
+    config = {
+      version: "1.0.0",
+      agents: [id],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } else {
+    if (!config.agents.includes(id)) {
+      config.agents.push(id);
+    }
+    config.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  saveConfig(config);
+  return paths;
+}
+function deployCaptureScript() {
+  const paths = ldmPaths();
+  mkdirSync(paths.bin, { recursive: true });
+  const thisDir = dirname(fileURLToPath(import.meta.url));
+  let scriptSrc = join(thisDir, "crystal-capture.sh");
+  if (!existsSync(scriptSrc)) {
+    scriptSrc = join(thisDir, "..", "scripts", "crystal-capture.sh");
+  }
+  const scriptDest = join(paths.bin, "crystal-capture.sh");
+  if (!existsSync(scriptSrc)) {
+    throw new Error(`crystal-capture.sh not found at ${scriptSrc}`);
+  }
+  copyFileSync(scriptSrc, scriptDest);
+  chmodSync(scriptDest, 493);
+  return scriptDest;
+}
+var CRON_TAG = "# crystal-capture";
+var CRON_ENTRY = "* * * * * ~/.ldm/bin/crystal-capture.sh >> /tmp/ldm-dev-tools/crystal-capture.log 2>&1";
+function isCrystalCaptureLine(line) {
+  return line === CRON_TAG || line.includes("crystal-capture.sh") && line.startsWith("*");
+}
+function installCron() {
+  mkdirSync("/tmp/ldm-dev-tools", { recursive: true });
+  let existing = "";
+  try {
+    existing = execSync("crontab -l 2>/dev/null", { encoding: "utf8" });
+  } catch {
+  }
+  const lines = existing.split("\n").filter((line) => !isCrystalCaptureLine(line));
+  lines.push(CRON_TAG);
+  lines.push(CRON_ENTRY);
+  const newCrontab = lines.filter((l, i, arr) => !(l === "" && i === arr.length - 1)).join("\n") + "\n";
+  execSync("crontab -", { input: newCrontab, encoding: "utf8" });
+}
+function removeCron() {
+  let existing = "";
+  try {
+    existing = execSync("crontab -l 2>/dev/null", { encoding: "utf8" });
+  } catch {
+    return;
+  }
+  const lines = existing.split("\n").filter((line) => !isCrystalCaptureLine(line));
+  const newCrontab = lines.join("\n");
+  execSync("crontab -", { input: newCrontab, encoding: "utf8" });
+}
+var LEGACY_OC_DIR = join(HOME, ".openclaw");
+function resolveStatePath(filename) {
+  const paths = ldmPaths();
+  const ldmPath = join(paths.state, filename);
+  if (existsSync(ldmPath)) return ldmPath;
+  const legacyPath = join(LEGACY_OC_DIR, "memory", filename);
+  if (existsSync(legacyPath)) return legacyPath;
+  return ldmPath;
+}
+function stateWritePath(filename) {
+  const paths = ldmPaths();
+  const dir = paths.state;
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return join(dir, filename);
+}
+function resolveSecretPath(filename) {
+  const paths = ldmPaths();
+  const ldmPath = join(paths.secrets, filename);
+  if (existsSync(ldmPath)) return ldmPath;
+  const legacyPath = join(LEGACY_OC_DIR, "secrets", filename);
+  if (existsSync(legacyPath)) return legacyPath;
+  return ldmPath;
+}
+function ensureLdm(agentId) {
+  const paths = ldmPaths(agentId);
+  if (existsSync(paths.transcripts) && existsSync(paths.config)) {
+    return paths;
+  }
+  return scaffoldLdm(agentId);
+}
+
+export {
+  getAgentId,
+  ldmPaths,
+  scaffoldLdm,
+  deployCaptureScript,
+  installCron,
+  removeCron,
+  resolveStatePath,
+  stateWritePath,
+  resolveSecretPath,
+  ensureLdm
+};

package/dist/chunk-ZCQYHTNU.js

@@ -0,0 +1,146 @@
+import {
+  ensureLdm,
+  ldmPaths
+} from "./chunk-EXEZZADG.js";
+
+// src/staging.ts
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { join } from "path";
+import { execSync } from "child_process";
+var HOME = process.env.HOME || "";
+var STAGING_ROOT = join(HOME, ".ldm", "staging");
+function stagingPaths(agentId) {
+  const root = join(STAGING_ROOT, agentId);
+  return {
+    root,
+    transcripts: join(root, "transcripts"),
+    readyFile: join(root, "READY")
+  };
+}
+function ensureStaging(agentId) {
+  const paths = stagingPaths(agentId);
+  mkdirSync(paths.transcripts, { recursive: true });
+  return paths;
+}
+function markReady(agentId) {
+  const paths = stagingPaths(agentId);
+  writeFileSync(paths.readyFile, JSON.stringify({
+    markedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    agentId
+  }));
+}
+function isNewAgent(agentId) {
+  const paths = ldmPaths(agentId);
+  return !existsSync(paths.agentRoot);
+}
+function hasStagedData(agentId) {
+  const paths = stagingPaths(agentId);
+  return existsSync(paths.readyFile);
+}
+function listStagedAgents() {
+  if (!existsSync(STAGING_ROOT)) return [];
+  const agents = [];
+  for (const entry of readdirSync(STAGING_ROOT, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    if (existsSync(join(STAGING_ROOT, entry.name, "READY"))) {
+      agents.push(entry.name);
+    }
+  }
+  return agents;
+}
+async function processStagedAgent(agentId) {
+  const startTime = Date.now();
+  const staging = stagingPaths(agentId);
+  if (!existsSync(staging.readyFile)) {
+    throw new Error(`No READY file for agent ${agentId}`);
+  }
+  const agentPaths = ensureLdm(agentId);
+  const stagedFiles = existsSync(staging.transcripts) ? readdirSync(staging.transcripts).filter((f) => f.endsWith(".jsonl")) : [];
+  if (stagedFiles.length === 0) {
+    unlinkSync(staging.readyFile);
+    return {
+      agentId,
+      transcriptsProcessed: 0,
+      backfillChunks: 0,
+      dreamWeaverRan: false,
+      durationMs: Date.now() - startTime
+    };
+  }
+  for (const file of stagedFiles) {
+    const src = join(staging.transcripts, file);
+    const dest = join(agentPaths.transcripts, file);
+    try {
+      renameSync(src, dest);
+    } catch {
+      const { copyFileSync } = await import("fs");
+      copyFileSync(src, dest);
+      unlinkSync(src);
+    }
+  }
+  let backfillChunks = 0;
+  let dreamWeaverRan = false;
+  try {
+    const output = execSync(
+      `crystal backfill --agent ${agentId}`,
+      { encoding: "utf-8", timeout: 6e5 }
+    );
+    const match = output.match(/(\d+) chunks embedded/);
+    if (match) backfillChunks = parseInt(match[1], 10);
+  } catch (err) {
+    process.stderr.write(`[staging] backfill failed for ${agentId}: ${err.message}
+`);
+  }
+  try {
+    execSync(
+      `crystal dream-weave --agent ${agentId} --mode full`,
+      { encoding: "utf-8", timeout: 6e5 }
+    );
+    dreamWeaverRan = true;
+  } catch (err) {
+    process.stderr.write(`[staging] dream-weave failed for ${agentId}: ${err.message}
+`);
+  }
+  try {
+    unlinkSync(staging.readyFile);
+  } catch {
+  }
+  return {
+    agentId,
+    transcriptsProcessed: stagedFiles.length,
+    backfillChunks,
+    dreamWeaverRan,
+    durationMs: Date.now() - startTime
+  };
+}
+async function processAllStaged() {
+  const agents = listStagedAgents();
+  const results = [];
+  for (const agentId of agents) {
+    try {
+      const result = await processStagedAgent(agentId);
+      results.push(result);
+    } catch (err) {
+      process.stderr.write(`[staging] failed to process ${agentId}: ${err.message}
+`);
+    }
+  }
+  return results;
+}
+
+export {
+  stagingPaths,
+  ensureStaging,
+  markReady,
+  isNewAgent,
+  hasStagedData,
+  listStagedAgents,
+  processStagedAgent,
+  processAllStaged
+};

package/dist/cli.d.ts

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