memory-crystal 0.2.0

package/dist/openclaw.js

@@ -0,0 +1,349 @@
+import {
+  Crystal,
+  resolveConfig
+} from "./chunk-52QE3YI3.js";
+
+// src/dev-update.ts
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { join, basename } from "path";
+var HOME = process.env.HOME || "";
+var STAFF_DIR = join(HOME, "Documents", "wipcomputer--mac-mini-01", "staff");
+var CC_REPOS = join(STAFF_DIR, "Parker", "Claude Code - Mini", "repos");
+var LESA_REPOS = join(STAFF_DIR, "L\u0113sa", "repos");
+var DEV_UPDATES_DIR = join(CC_REPOS, "wip-dev-updates");
+var LAST_RUN_PATH = join(HOME, ".openclaw", "memory", "dev-update-last-run.json");
+function loadLastRun() {
+  try {
+    if (existsSync(LAST_RUN_PATH)) {
+      return JSON.parse(readFileSync(LAST_RUN_PATH, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function saveLastRun(run) {
+  const dir = join(HOME, ".openclaw", "memory");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(LAST_RUN_PATH, JSON.stringify(run, null, 2));
+}
+function git(repoPath, cmd) {
+  try {
+    return execSync(`git -C "${repoPath}" ${cmd}`, {
+      encoding: "utf-8",
+      timeout: 1e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+function scanRepo(repoPath, since) {
+  if (!existsSync(join(repoPath, ".git"))) return null;
+  const name = basename(repoPath);
+  if (name === "_third-party-repos" || name === "wip-dev-updates") return null;
+  const recentCommits = git(repoPath, `log --oneline --since="${since}"`);
+  const uncommitted = git(repoPath, "status --porcelain");
+  if (!recentCommits && !uncommitted) return null;
+  const lines = [];
+  lines.push(`# ${name}`);
+  lines.push("");
+  if (recentCommits) {
+    lines.push("## Recent Commits");
+    lines.push("");
+    lines.push("```");
+    lines.push(...recentCommits.split("\n").slice(0, 10));
+    lines.push("```");
+    lines.push("");
+  }
+  if (uncommitted) {
+    lines.push("## Uncommitted Changes");
+    lines.push("");
+    lines.push("```");
+    lines.push(...uncommitted.split("\n").slice(0, 20));
+    lines.push("```");
+    lines.push("");
+  }
+  if (recentCommits) {
+    const diffStat = git(repoPath, `diff --stat "HEAD@{${since}}" HEAD`);
+    if (diffStat) {
+      lines.push("## Files Changed");
+      lines.push("");
+      lines.push("```");
+      lines.push(...diffStat.split("\n").slice(-15));
+      lines.push("```");
+      lines.push("");
+    }
+  }
+  const branch = git(repoPath, "branch --show-current") || "unknown";
+  lines.push(`**Branch:** ${branch}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function runDevUpdate(author) {
+  const lastRun = loadLastRun();
+  if (lastRun) {
+    const elapsed = Date.now() - new Date(lastRun.timestamp).getTime();
+    if (elapsed < 60 * 60 * 1e3) {
+      return { reposUpdated: 0, files: [] };
+    }
+  }
+  let since = "6 hours ago";
+  if (lastRun?.timestamp) {
+    const lastDate = new Date(lastRun.timestamp);
+    const hoursAgo = Math.ceil((Date.now() - lastDate.getTime()) / (1e3 * 60 * 60));
+    since = `${Math.max(hoursAgo, 1)} hours ago`;
+  }
+  const now = /* @__PURE__ */ new Date();
+  const ts = [
+    String(now.getMonth() + 1).padStart(2, "0"),
+    String(now.getDate()).padStart(2, "0"),
+    String(now.getFullYear())
+  ].join("-") + "--" + [
+    String(now.getHours()).padStart(2, "0"),
+    String(now.getMinutes()).padStart(2, "0"),
+    String(now.getSeconds()).padStart(2, "0")
+  ].join("-");
+  const files = [];
+  const repoDirs = [CC_REPOS, LESA_REPOS];
+  for (const parentDir of repoDirs) {
+    if (!existsSync(parentDir)) continue;
+    let entries;
+    try {
+      entries = execSync(`ls "${parentDir}"`, { encoding: "utf-8" }).trim().split("\n");
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const repoPath = join(parentDir, entry);
+      const content = scanRepo(repoPath, since);
+      if (!content) continue;
+      const repoName = basename(repoPath);
+      const outDir = join(repoPath, "ai");
+      const outFile = join(outDir, `${now.toISOString().slice(0, 10)}--${now.toISOString().slice(11, 19).replace(/:/g, "-")}--${author}--dev-update-${repoName}.md`);
+      mkdirSync(outDir, { recursive: true });
+      const header = `*Auto-generated dev update by ${author} at ${now.toISOString().slice(0, 16).replace("T", " ")}*
+
+`;
+      writeFileSync(outFile, content.replace(/^# .+\n/, `$&
+${header}`));
+      files.push(`${repoName}/ai/${basename(outFile)}`);
+    }
+  }
+  if (false) {
+    try {
+      execSync(
+        `cd "${DEV_UPDATES_DIR}" && git add -A && git commit -m "${author} auto-dev-update ${ts}: ${files.length} repo(s)" --no-verify && git push --quiet`,
+        { encoding: "utf-8", timeout: 3e4, stdio: "pipe" }
+      );
+    } catch {
+    }
+  }
+  saveLastRun({
+    timestamp: now.toISOString(),
+    author,
+    reposUpdated: files.length
+  });
+  return { reposUpdated: files.length, files };
+}
+
+// src/openclaw.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+var CONFIG_DIR = join2(process.env.HOME || "", ".openclaw");
+var PRIVATE_MODE_PATH = join2(CONFIG_DIR, "memory", "memory-capture-state.json");
+function isPrivateMode() {
+  try {
+    if (existsSync2(PRIVATE_MODE_PATH)) {
+      const state = JSON.parse(readFileSync2(PRIVATE_MODE_PATH, "utf-8"));
+      return state.enabled === false;
+    }
+  } catch {
+  }
+  return false;
+}
+var openclaw_default = {
+  register(api) {
+    const crystal = new Crystal(resolveConfig());
+    let initialized = false;
+    async function ensureInit() {
+      if (!initialized) {
+        await crystal.init();
+        initialized = true;
+      }
+    }
+    api.on("agent_end", async (event, ctx) => {
+      if (isPrivateMode()) return;
+      await ensureInit();
+      const messages = event.messages;
+      if (!messages || messages.length === 0) return;
+      const agentId = ctx.agentId || "main";
+      const sessionKey = ctx.sessionKey || "unknown";
+      const state = crystal.getCaptureState(agentId, sessionKey);
+      const storedCount = state.lastMessageCount;
+      let startIndex = storedCount;
+      if (messages.length < storedCount) {
+        api.logger.info(`memory-crystal: compaction detected (${storedCount} \u2192 ${messages.length} messages), resetting capture position`);
+        startIndex = 0;
+      }
+      if (messages.length <= startIndex) return;
+      const newTurns = [];
+      for (let i = startIndex; i < messages.length; i++) {
+        const msg = messages[i];
+        if (!msg.content) continue;
+        const role = msg.role;
+        if (role !== "user" && role !== "assistant") continue;
+        let text = "";
+        if (typeof msg.content === "string") {
+          text = msg.content;
+        } else if (Array.isArray(msg.content)) {
+          text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+        }
+        if (!text || text.length < 50) continue;
+        const maxSingleChunkChars = 2e3 * 4;
+        if (text.length <= maxSingleChunkChars) {
+          newTurns.push({
+            text,
+            role,
+            source_type: "conversation",
+            source_id: sessionKey,
+            agent_id: agentId,
+            token_count: Math.ceil(text.length / 4),
+            created_at: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        } else {
+          const chunks = crystal.chunkText(text);
+          for (const chunkText of chunks) {
+            newTurns.push({
+              text: chunkText,
+              role,
+              source_type: "conversation",
+              source_id: sessionKey,
+              agent_id: agentId,
+              token_count: Math.ceil(chunkText.length / 4),
+              created_at: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        }
+      }
+      const totalTokens = newTurns.reduce((sum, c) => sum + c.token_count, 0);
+      if (totalTokens < 500) return;
+      try {
+        const count = await crystal.ingest(newTurns);
+        crystal.setCaptureState(agentId, sessionKey, messages.length, state.captureCount + 1);
+        api.logger.info(`memory-crystal: ingested ${count} chunks from ${sessionKey} (cycle ${state.captureCount + 1})`);
+      } catch (err) {
+        api.logger.error(`memory-crystal: ingest error: ${err.message}`);
+      }
+    });
+    function toolResult(text, isError = false) {
+      return {
+        content: [{ type: "text", text }],
+        ...isError ? { isError: true } : {}
+      };
+    }
+    api.registerTool(
+      {
+        name: "crystal_search",
+        label: "Search Memory Crystal",
+        description: "Search memory crystal \u2014 semantic search across all conversations and stored memories.",
+        parameters: {
+          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" }
+          },
+          required: ["query"]
+        },
+        async execute(_id, params) {
+          try {
+            await ensureInit();
+            const results = await crystal.search(
+              params.query,
+              params.limit || 5,
+              params.agent_id ? { agent_id: params.agent_id } : void 0
+            );
+            if (results.length === 0) return toolResult("No results found.");
+            const formatted = results.map((r, i) => {
+              const score = (r.score * 100).toFixed(1);
+              const date = r.created_at?.slice(0, 10) || "unknown";
+              return `[${i + 1}] (${score}%, ${r.agent_id}, ${date}, ${r.role})
+${r.text}`;
+            }).join("\n\n---\n\n");
+            return toolResult(formatted);
+          } catch (err) {
+            return toolResult(`crystal_search error: ${err.message}`, true);
+          }
+        }
+      },
+      { optional: true }
+    );
+    api.registerTool(
+      {
+        name: "crystal_remember",
+        label: "Remember in Crystal",
+        description: "Store a fact, preference, or observation in memory crystal.",
+        parameters: {
+          type: "object",
+          properties: {
+            text: { type: "string", description: "The fact to remember" },
+            category: { type: "string", enum: ["fact", "preference", "event", "opinion", "skill"] }
+          },
+          required: ["text"]
+        },
+        async execute(_id, params) {
+          if (isPrivateMode()) {
+            return toolResult("Private mode is on. No memories are being stored. Use /private-mode off to resume.");
+          }
+          try {
+            await ensureInit();
+            const id = await crystal.remember(params.text, params.category || "fact");
+            return toolResult(`Remembered (id: ${id}): ${params.text}`);
+          } catch (err) {
+            return toolResult(`crystal_remember error: ${err.message}`, true);
+          }
+        }
+      },
+      { optional: true }
+    );
+    api.registerTool(
+      {
+        name: "crystal_forget",
+        label: "Forget Memory",
+        description: "Deprecate a memory by ID.",
+        parameters: {
+          type: "object",
+          properties: {
+            id: { type: "number", description: "Memory ID to deprecate" }
+          },
+          required: ["id"]
+        },
+        async execute(_id, params) {
+          try {
+            await ensureInit();
+            const ok = crystal.forget(params.id);
+            return toolResult(ok ? `Forgot memory ${params.id}` : `Memory ${params.id} not found`);
+          } catch (err) {
+            return toolResult(`crystal_forget error: ${err.message}`, true);
+          }
+        }
+      },
+      { optional: true }
+    );
+    api.on("before_compaction", (_event, _ctx) => {
+      try {
+        const result = runDevUpdate("lesa");
+        if (result.reposUpdated > 0) {
+          api.logger.info(`memory-crystal: auto-dev-update wrote ${result.reposUpdated} updates before compaction`);
+        }
+      } catch (err) {
+        api.logger.warn(`memory-crystal: auto-dev-update failed: ${err.message}`);
+      }
+    });
+    api.logger.info("memory-crystal plugin registered");
+  }
+};
+export {
+  openclaw_default as default
+};

package/dist/poller.d.ts

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

package/dist/poller.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+import {
+  generateSessionSummary,
+  writeSummaryFile
+} from "./chunk-Y72C7F6O.js";
+import {
+  Crystal,
+  resolveConfig
+} from "./chunk-52QE3YI3.js";
+import {
+  decryptJSON,
+  encrypt,
+  hashBuffer,
+  loadRelayKey
+} from "./chunk-F3Y7EL7K.js";
+import {
+  ensureLdm,
+  ldmPaths
+} from "./chunk-PJ6FFKEX.js";
+
+// src/poller.ts
+import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync } 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 POLLER_STATE_PATH = join(OC_DIR, "memory", "relay-poller-state.json");
+function loadState() {
+  try {
+    if (existsSync(POLLER_STATE_PATH)) {
+      return JSON.parse(readFileSync(POLLER_STATE_PATH, "utf-8"));
+    }
+  } catch {
+  }
+  return { lastPoll: null, totalIngested: 0, lastMirrorPush: null };
+}
+function saveState(state) {
+  const dir = dirname(POLLER_STATE_PATH);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(POLLER_STATE_PATH, JSON.stringify(state, null, 2));
+}
+async function pollOnce() {
+  if (!RELAY_URL || !RELAY_TOKEN) {
+    throw new Error("CRYSTAL_RELAY_URL and CRYSTAL_RELAY_TOKEN must be set");
+  }
+  const relayKey = loadRelayKey();
+  let ingested = 0;
+  let errors = 0;
+  const listResp = await fetch(`${RELAY_URL}/pickup/conversations`, {
+    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) {
+    return { ingested: 0, errors: 0 };
+  }
+  process.stderr.write(`[relay-poller] ${listData.count} blob(s) waiting
+`);
+  const config = resolveConfig();
+  const crystal = new Crystal(config);
+  await crystal.init();
+  for (const blob of listData.blobs) {
+    try {
+      const blobResp = await fetch(`${RELAY_URL}/pickup/conversations/${blob.id}`, {
+        headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+      });
+      if (!blobResp.ok) {
+        process.stderr.write(`[relay-poller] failed to fetch blob ${blob.id}: ${blobResp.status}
+`);
+        errors++;
+        continue;
+      }
+      const encryptedText = await blobResp.text();
+      const encrypted = JSON.parse(encryptedText);
+      let drop;
+      try {
+        drop = decryptJSON(encrypted, relayKey);
+      } catch (err) {
+        process.stderr.write(`[relay-poller] blob ${blob.id} failed verification: ${err.message} \u2014 DISCARDED
+`);
+        await fetch(`${RELAY_URL}/confirm/conversations/${blob.id}`, {
+          method: "DELETE",
+          headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+        });
+        errors++;
+        continue;
+      }
+      const maxSingleChunkChars = 2e3 * 4;
+      const chunks = [];
+      for (const msg of drop.messages) {
+        if (msg.text.length <= maxSingleChunkChars) {
+          chunks.push({
+            text: msg.text,
+            role: msg.role,
+            source_type: "conversation",
+            source_id: `cc:${msg.sessionId}`,
+            agent_id: drop.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: drop.agent_id,
+              token_count: Math.ceil(ct.length / 4),
+              created_at: msg.timestamp
+            });
+          }
+        }
+      }
+      const count = await crystal.ingest(chunks);
+      ingested += count;
+      await fetch(`${RELAY_URL}/confirm/conversations/${blob.id}`, {
+        method: "DELETE",
+        headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+      });
+      process.stderr.write(`[relay-poller] blob ${blob.id}: ${count} chunks ingested from ${drop.agent_id}
+`);
+      try {
+        const remotePaths = ensureLdm(drop.agent_id);
+        const jsonlPath = join(remotePaths.transcripts, `relay-${blob.id}.jsonl`);
+        const jsonlLines = drop.messages.map((m) => JSON.stringify(m)).join("\n") + "\n";
+        writeFileSync(jsonlPath, jsonlLines);
+        const summaryMsgs = drop.messages.map((m) => ({
+          role: m.role,
+          text: m.text,
+          timestamp: m.timestamp,
+          sessionId: m.sessionId
+        }));
+        const summary = await generateSessionSummary(summaryMsgs);
+        const sessionId = drop.messages[0]?.sessionId || "unknown";
+        writeSummaryFile(remotePaths.sessions, summary, drop.agent_id, sessionId);
+        const now = /* @__PURE__ */ new Date();
+        const dateStr = now.toISOString().slice(0, 10);
+        const dailyPath = join(remotePaths.daily, `${dateStr}.md`);
+        if (!existsSync(dailyPath)) {
+          writeFileSync(dailyPath, `# ${dateStr} - ${drop.agent_id} Daily Log (via relay)
+
+`);
+        }
+        const firstUser = drop.messages.find((m) => m.role === "user");
+        if (firstUser) {
+          const snippet = firstUser.text.slice(0, 120).replace(/\n/g, " ").trim();
+          appendFileSync(dailyPath, `- **${now.toISOString().slice(11, 16)}** [relay] ${snippet}
+`);
+        }
+      } catch (fileErr) {
+        process.stderr.write(`[relay-poller] file tree write failed (non-fatal): ${fileErr.message}
+`);
+      }
+    } catch (err) {
+      process.stderr.write(`[relay-poller] error processing blob ${blob.id}: ${err.message}
+`);
+      errors++;
+    }
+  }
+  return { ingested, errors };
+}
+async function pushMirror() {
+  if (!RELAY_URL || !RELAY_TOKEN) {
+    throw new Error("CRYSTAL_RELAY_URL and CRYSTAL_RELAY_TOKEN must be set");
+  }
+  const relayKey = loadRelayKey();
+  const config = resolveConfig();
+  const paths = ldmPaths();
+  const dbPath = existsSync(paths.crystalDb) ? paths.crystalDb : join(config.dataDir || join(OC_DIR, "memory-crystal"), "crystal.db");
+  if (!existsSync(dbPath)) {
+    throw new Error(`Crystal DB not found at ${dbPath}`);
+  }
+  const dbData = readFileSync(dbPath);
+  const dbHash = hashBuffer(dbData);
+  const mirrorMeta = JSON.stringify({ hash: dbHash, size: dbData.length, pushed_at: (/* @__PURE__ */ new Date()).toISOString() });
+  const metaEncrypted = encrypt(Buffer.from(mirrorMeta, "utf-8"), relayKey);
+  const dbEncrypted = encrypt(dbData, relayKey);
+  const payload = JSON.stringify({
+    meta: metaEncrypted,
+    db: dbEncrypted
+  });
+  const resp = await fetch(`${RELAY_URL}/drop/mirror`, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${RELAY_TOKEN}`,
+      "Content-Type": "application/octet-stream"
+    },
+    body: payload
+  });
+  if (!resp.ok) {
+    throw new Error(`Mirror push failed: ${resp.status} ${await resp.text()}`);
+  }
+  const result = await resp.json();
+  process.stderr.write(`[relay-poller] mirror pushed: ${(dbData.length / 1024 / 1024).toFixed(1)}MB, hash=${dbHash.slice(0, 12)}...
+`);
+}
+var args = process.argv.slice(2);
+if (args.includes("--status")) {
+  const state = loadState();
+  const mode = RELAY_URL && RELAY_TOKEN ? "configured" : "not configured";
+  console.log(`Relay poller status:`);
+  console.log(`  Relay URL:      ${RELAY_URL || "(not set)"}`);
+  console.log(`  Mode:           ${mode}`);
+  console.log(`  Last poll:      ${state.lastPoll || "never"}`);
+  console.log(`  Total ingested: ${state.totalIngested}`);
+  console.log(`  Last mirror:    ${state.lastMirrorPush || "never"}`);
+  process.exit(0);
+}
+if (args.includes("--push-mirror")) {
+  pushMirror().then(() => {
+    const state = loadState();
+    state.lastMirrorPush = (/* @__PURE__ */ new Date()).toISOString();
+    saveState(state);
+    process.exit(0);
+  }).catch((err) => {
+    process.stderr.write(`[relay-poller] mirror push error: ${err.message}
+`);
+    process.exit(1);
+  });
+} else if (args.includes("--watch")) {
+  const POLL_INTERVAL = 2 * 60 * 1e3;
+  async function loop() {
+    process.stderr.write(`[relay-poller] watching (every ${POLL_INTERVAL / 1e3}s)...
+`);
+    while (true) {
+      try {
+        const { ingested, errors } = await pollOnce();
+        const state = loadState();
+        state.lastPoll = (/* @__PURE__ */ new Date()).toISOString();
+        state.totalIngested += ingested;
+        saveState(state);
+        if (ingested > 0) {
+          process.stderr.write(`[relay-poller] poll complete: ${ingested} ingested, ${errors} errors
+`);
+          try {
+            await pushMirror();
+            state.lastMirrorPush = (/* @__PURE__ */ new Date()).toISOString();
+            saveState(state);
+          } catch (mirrorErr) {
+            process.stderr.write(`[relay-poller] mirror push failed (non-fatal): ${mirrorErr.message}
+`);
+          }
+        }
+      } catch (err) {
+        process.stderr.write(`[relay-poller] poll error: ${err.message}
+`);
+      }
+      await new Promise((r) => setTimeout(r, POLL_INTERVAL));
+    }
+  }
+  loop();
+} else {
+  pollOnce().then(({ ingested, errors }) => {
+    const state = loadState();
+    state.lastPoll = (/* @__PURE__ */ new Date()).toISOString();
+    state.totalIngested += ingested;
+    saveState(state);
+    if (ingested > 0) {
+      process.stderr.write(`[relay-poller] ${ingested} chunks ingested, ${errors} errors
+`);
+    }
+    process.exit(errors > 0 ? 1 : 0);
+  }).catch((err) => {
+    process.stderr.write(`[relay-poller] error: ${err.message}
+`);
+    process.exit(1);
+  });
+}

package/dist/summarize.d.ts

@@ -0,0 +1,19 @@
+interface SessionSummary {
+    title: string;
+    slug: string;
+    summary: string;
+    topics: string[];
+    messageCount: number;
+    date: string;
+}
+interface SummaryMessage {
+    role: string;
+    text: string;
+    timestamp: string;
+    sessionId: string;
+}
+declare function generateSessionSummary(messages: SummaryMessage[]): Promise<SessionSummary>;
+declare function formatSummaryMarkdown(summary: SessionSummary, sessionId: string): string;
+declare function writeSummaryFile(sessionsDir: string, summary: SessionSummary, agentId: string, sessionId: string): string;
+
+export { type SessionSummary, type SummaryMessage, formatSummaryMarkdown, generateSessionSummary, writeSummaryFile };

package/dist/summarize.js

@@ -0,0 +1,10 @@
+import {
+  formatSummaryMarkdown,
+  generateSessionSummary,
+  writeSummaryFile
+} from "./chunk-Y72C7F6O.js";
+export {
+  formatSummaryMarkdown,
+  generateSessionSummary,
+  writeSummaryFile
+};