@wipcomputer/memory-crystal 0.7.29 → 0.7.32

package/dist/cc-hook.js

@@ -1,368 +0,0 @@
-#!/usr/bin/env node
-import {
-  createCrystal,
-  resolveConfig
-} from "./chunk-FBQWSDPC.js";
-import {
-  encryptJSON,
-  loadRelayKey
-} from "./chunk-KCQUXVYT.js";
-import {
-  ensureLdm,
-  getAgentId,
-  ldmPaths,
-  resolveStatePath,
-  stateWritePath
-} from "./chunk-EXEZZADG.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

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