@wipcomputer/memory-crystal 0.7.34-alpha.2 → 0.7.34-alpha.4

package/dist/chunk-YX6AXLVK.js

@@ -1,159 +0,0 @@
-// 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

@@ -1,146 +0,0 @@
-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/cloud-crystal.js

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

package/dist/dev-update-SZ2Z4WCQ.js

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

package/dist/llm-XXLYPIOF.js

@@ -1,16 +0,0 @@
-import {
-  detectProvider,
-  expandQuery,
-  hasSampling,
-  rerankResults,
-  setLLMCacheDb,
-  setSamplingServer
-} from "./chunk-NX647OM3.js";
-export {
-  detectProvider,
-  expandQuery,
-  hasSampling,
-  rerankResults,
-  setLLMCacheDb,
-  setSamplingServer
-};

package/dist/mlx-setup-XKU67WCT.js

@@ -1,289 +0,0 @@
-// src/mlx-setup.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { execSync } from "child_process";
-import { join } from "path";
-import { homedir } from "os";
-var HOME = homedir();
-var MLX_PORT = 18791;
-var MLX_MODEL = "mlx-community/Qwen2.5-3B-Instruct-4bit";
-var MLX_STATE_FILE = join(HOME, ".ldm", "state", "mlx-server.json");
-var MLX_PLIST_LABEL = "ai.ldm.mlx-server";
-var MLX_PLIST_PATH = join(HOME, "Library", "LaunchAgents", `${MLX_PLIST_LABEL}.plist`);
-var MLX_LOG_PATH = "/tmp/mlx-server.log";
-function detectPlatform() {
-  const platform = process.platform;
-  const arch = process.arch;
-  if (platform === "darwin") {
-    return arch === "arm64" ? "apple-silicon" : "intel-mac";
-  }
-  if (platform === "linux") return "linux";
-  return "other";
-}
-function canRunMlx() {
-  return detectPlatform() === "apple-silicon";
-}
-function findPython() {
-  const candidates = ["python3", "/opt/homebrew/bin/python3", "/usr/local/bin/python3"];
-  for (const cmd of candidates) {
-    try {
-      const version = execSync(`${cmd} --version 2>&1`, { encoding: "utf-8", timeout: 5e3 }).trim();
-      const match = version.match(/Python (\d+)\.(\d+)/);
-      if (match && parseInt(match[1]) >= 3 && parseInt(match[2]) >= 10) {
-        const realPath = execSync(`which ${cmd} 2>/dev/null`, { encoding: "utf-8", timeout: 3e3 }).trim();
-        return realPath || cmd;
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-function findInstaller() {
-  try {
-    execSync("uv --version 2>/dev/null", { encoding: "utf-8", timeout: 3e3 });
-    return "uv";
-  } catch {
-  }
-  try {
-    execSync("pip3 --version 2>/dev/null", { encoding: "utf-8", timeout: 3e3 });
-    return "pip3";
-  } catch {
-  }
-  return null;
-}
-function isMlxLmInstalled() {
-  try {
-    execSync('python3 -c "import mlx_lm" 2>/dev/null', { timeout: 5e3 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function installMlxLm(steps) {
-  const installer = findInstaller();
-  if (!installer) {
-    steps.push("No pip3 or uv found. Cannot install mlx-lm.");
-    return false;
-  }
-  const cmd = installer === "uv" ? "uv pip install mlx-lm" : "pip3 install mlx-lm";
-  steps.push(`Installing mlx-lm via ${installer}...`);
-  try {
-    execSync(cmd, { encoding: "utf-8", timeout: 12e4, stdio: "pipe" });
-    steps.push("mlx-lm installed successfully.");
-    return true;
-  } catch (err) {
-    if (installer === "pip3") {
-      try {
-        execSync("pip3 install --user mlx-lm", { encoding: "utf-8", timeout: 12e4, stdio: "pipe" });
-        steps.push("mlx-lm installed (--user) successfully.");
-        return true;
-      } catch {
-      }
-    }
-    steps.push(`mlx-lm install failed: ${err.message.slice(0, 200)}`);
-    return false;
-  }
-}
-function isServerRunning() {
-  try {
-    const state = loadState();
-    const port = state?.port || MLX_PORT;
-    execSync(`curl -s -o /dev/null -w "%{http_code}" http://localhost:${port}/v1/models`, {
-      encoding: "utf-8",
-      timeout: 3e3
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function createLaunchAgent(pythonPath, steps) {
-  const plist = `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>${MLX_PLIST_LABEL}</string>
-  <key>ProgramArguments</key>
-  <array>
-    <string>${pythonPath}</string>
-    <string>-m</string>
-    <string>mlx_lm.server</string>
-    <string>--model</string>
-    <string>${MLX_MODEL}</string>
-    <string>--port</string>
-    <string>${MLX_PORT}</string>
-  </array>
-  <key>RunAtLoad</key>
-  <true/>
-  <key>KeepAlive</key>
-  <true/>
-  <key>StandardOutPath</key>
-  <string>${MLX_LOG_PATH}</string>
-  <key>StandardErrorPath</key>
-  <string>${MLX_LOG_PATH}</string>
-</dict>
-</plist>`;
-  try {
-    writeFileSync(MLX_PLIST_PATH, plist);
-    execSync(`launchctl load "${MLX_PLIST_PATH}" 2>/dev/null`, { timeout: 5e3 });
-    steps.push(`LaunchAgent installed at ${MLX_PLIST_PATH}`);
-    steps.push(`MLX server will start on port ${MLX_PORT}`);
-    return true;
-  } catch (err) {
-    steps.push(`LaunchAgent install failed: ${err.message}`);
-    return false;
-  }
-}
-function startServer(steps) {
-  try {
-    execSync(`launchctl kickstart -kp gui/$(id -u)/${MLX_PLIST_LABEL} 2>/dev/null`, { timeout: 1e4 });
-    steps.push("MLX server started.");
-    return true;
-  } catch {
-    steps.push("MLX server start failed. Check /tmp/mlx-server.log");
-    return false;
-  }
-}
-function stopServer() {
-  try {
-    execSync(`launchctl unload "${MLX_PLIST_PATH}" 2>/dev/null`, { timeout: 5e3 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function loadState() {
-  try {
-    if (existsSync(MLX_STATE_FILE)) {
-      return JSON.parse(readFileSync(MLX_STATE_FILE, "utf-8"));
-    }
-  } catch {
-  }
-  return null;
-}
-function saveState(state) {
-  const dir = join(HOME, ".ldm", "state");
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync(MLX_STATE_FILE, JSON.stringify(state, null, 2) + "\n");
-}
-async function verifyServer(steps) {
-  const state = loadState();
-  const port = state?.port || MLX_PORT;
-  for (let i = 0; i < 15; i++) {
-    try {
-      const resp = await fetch(`http://localhost:${port}/v1/models`, {
-        signal: AbortSignal.timeout(2e3)
-      });
-      if (resp.ok) {
-        const data = await resp.json();
-        const model = data?.data?.[0]?.id || "unknown";
-        steps.push(`MLX server verified: ${model} on port ${port}`);
-        return true;
-      }
-    } catch {
-    }
-    await new Promise((r) => setTimeout(r, 2e3));
-  }
-  steps.push("MLX server did not respond within 30 seconds. Check /tmp/mlx-server.log");
-  return false;
-}
-async function setupMlx(options) {
-  const steps = [];
-  const platform = detectPlatform();
-  if (platform !== "apple-silicon") {
-    steps.push(`Platform: ${platform}. MLX requires Apple Silicon. Skipping.`);
-    return { ok: false, steps };
-  }
-  steps.push("Platform: Apple Silicon detected.");
-  const pythonPath = findPython();
-  if (!pythonPath) {
-    steps.push("Python 3.10+ not found. Install via: brew install python3");
-    return { ok: false, steps };
-  }
-  steps.push(`Python: ${pythonPath}`);
-  if (!isMlxLmInstalled()) {
-    if (!options?.yes) {
-      steps.push("mlx-lm not installed. Run with --yes to auto-install, or: pip3 install mlx-lm");
-      return { ok: false, steps };
-    }
-    const installed = installMlxLm(steps);
-    if (!installed) return { ok: false, steps };
-  } else {
-    steps.push("mlx-lm: already installed.");
-  }
-  if (!existsSync(MLX_PLIST_PATH)) {
-    const created = createLaunchAgent(pythonPath, steps);
-    if (!created) return { ok: false, steps };
-  } else {
-    steps.push("LaunchAgent: already installed.");
-  }
-  saveState({
-    installed: true,
-    port: MLX_PORT,
-    model: MLX_MODEL,
-    pythonPath,
-    installedAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  if (!isServerRunning()) {
-    startServer(steps);
-    steps.push(`Waiting for model to load (~1.5 GB on first run)...`);
-    const verified = await verifyServer(steps);
-    if (!verified) {
-      steps.push("Server started but not yet responding. It may still be downloading the model.");
-      steps.push(`Check: tail -f ${MLX_LOG_PATH}`);
-    }
-  } else {
-    steps.push(`MLX server: already running on port ${MLX_PORT}`);
-  }
-  return { ok: true, steps };
-}
-function doctorCheck() {
-  const platform = detectPlatform();
-  if (platform !== "apple-silicon") {
-    return { status: "skip", detail: `${platform} (MLX requires Apple Silicon)` };
-  }
-  const state = loadState();
-  if (!state || !state.installed) {
-    return {
-      status: "warn",
-      detail: "not installed",
-      fix: "crystal init (will offer MLX setup)"
-    };
-  }
-  if (isServerRunning()) {
-    return { status: "ok", detail: `running on port ${state.port} (${state.model})` };
-  }
-  if (existsSync(MLX_PLIST_PATH)) {
-    return {
-      status: "warn",
-      detail: "installed but not running",
-      fix: `launchctl kickstart -kp gui/$(id -u)/${MLX_PLIST_LABEL}`
-    };
-  }
-  return {
-    status: "warn",
-    detail: "installed but LaunchAgent missing",
-    fix: "crystal init (will recreate LaunchAgent)"
-  };
-}
-var MLX_CONFIG = {
-  port: MLX_PORT,
-  model: MLX_MODEL,
-  plistPath: MLX_PLIST_PATH,
-  logPath: MLX_LOG_PATH,
-  stateFile: MLX_STATE_FILE
-};
-export {
-  MLX_CONFIG,
-  canRunMlx,
-  createLaunchAgent,
-  detectPlatform,
-  doctorCheck,
-  installMlxLm,
-  isMlxLmInstalled,
-  isServerRunning,
-  setupMlx,
-  startServer,
-  stopServer,
-  verifyServer
-};