memory-crystal 0.2.0

package/dist/chunk-Y72C7F6O.js

@@ -0,0 +1,148 @@
+// src/summarize.ts
+import { writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import https from "https";
+import http from "http";
+var SUMMARY_MODE = process.env.CRYSTAL_SUMMARY_MODE || "simple";
+var SUMMARY_PROVIDER = process.env.CRYSTAL_SUMMARY_PROVIDER || "openai";
+var SUMMARY_MODEL = process.env.CRYSTAL_SUMMARY_MODEL || "gpt-4o-mini";
+function generateSimpleSummary(messages) {
+  const firstUser = messages.find((m) => m.role === "user");
+  const title = firstUser ? firstUser.text.slice(0, 80).replace(/\n/g, " ").trim() : "Untitled Session";
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
+  const preview = messages.slice(0, 10).map((m) => {
+    const roleLabel = m.role === "user" ? "User" : "Assistant";
+    const snippet = m.text.slice(0, 200).replace(/\n/g, " ").trim();
+    return `**${roleLabel}:** ${snippet}${m.text.length > 200 ? "..." : ""}`;
+  }).join("\n\n");
+  const date = messages[0]?.timestamp?.slice(0, 10) || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return {
+    title,
+    slug,
+    summary: preview,
+    topics: [],
+    messageCount: messages.length,
+    date
+  };
+}
+async function generateLlmSummary(messages) {
+  const condensed = messages.slice(0, 30).map((m) => {
+    const roleLabel = m.role === "user" ? "User" : "Assistant";
+    const text = m.text.slice(0, 500);
+    return `${roleLabel}: ${text}`;
+  }).join("\n\n");
+  const prompt = `Summarize this conversation. Return JSON only, no markdown fences.
+
+Format:
+{"title": "short title", "slug": "url-safe-slug", "summary": "2-4 sentences", "topics": ["topic1", "topic2"]}
+
+Conversation:
+${condensed}`;
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    return generateSimpleSummary(messages);
+  }
+  try {
+    const body = JSON.stringify({
+      model: SUMMARY_MODEL,
+      messages: [{ role: "user", content: prompt }],
+      temperature: 0.3,
+      max_tokens: 300
+    });
+    const result = await httpPost("https://api.openai.com/v1/chat/completions", body, {
+      "Authorization": `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    });
+    const parsed = JSON.parse(result);
+    const content = parsed.choices?.[0]?.message?.content || "";
+    const jsonStr = content.replace(/```json?\n?/g, "").replace(/```/g, "").trim();
+    const data = JSON.parse(jsonStr);
+    const date = messages[0]?.timestamp?.slice(0, 10) || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    return {
+      title: data.title || "Untitled",
+      slug: (data.slug || "untitled").slice(0, 50),
+      summary: data.summary || "",
+      topics: data.topics || [],
+      messageCount: messages.length,
+      date
+    };
+  } catch {
+    return generateSimpleSummary(messages);
+  }
+}
+function httpPost(url, body, headers) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const client = parsed.protocol === "https:" ? https : http;
+    const req = client.request({
+      hostname: parsed.hostname,
+      port: parsed.port,
+      path: parsed.pathname + parsed.search,
+      method: "POST",
+      headers: { ...headers, "Content-Length": Buffer.byteLength(body) },
+      timeout: 3e4
+    }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+          resolve(data);
+        } else {
+          reject(new Error(`HTTP ${res.statusCode}: ${data.slice(0, 200)}`));
+        }
+      });
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timeout"));
+    });
+    req.write(body);
+    req.end();
+  });
+}
+async function generateSessionSummary(messages) {
+  if (SUMMARY_MODE === "llm") {
+    return generateLlmSummary(messages);
+  }
+  return generateSimpleSummary(messages);
+}
+function formatSummaryMarkdown(summary, sessionId) {
+  const lines = [];
+  lines.push(`# ${summary.title}`);
+  lines.push("");
+  lines.push(`**Session:** ${sessionId}  **Date:** ${summary.date}  **Messages:** ${summary.messageCount}`);
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(summary.summary);
+  if (summary.topics.length > 0) {
+    lines.push("");
+    lines.push("## Key Topics");
+    lines.push("");
+    for (const topic of summary.topics) {
+      lines.push(`- ${topic}`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function writeSummaryFile(sessionsDir, summary, agentId, sessionId) {
+  if (!existsSync(sessionsDir)) mkdirSync(sessionsDir, { recursive: true });
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = now.toISOString().slice(0, 10);
+  const timeStr = now.toISOString().slice(11, 19).replace(/:/g, "-");
+  const filename = `${dateStr}--${timeStr}--${agentId}--${summary.slug}.md`;
+  const filepath = join(sessionsDir, filename);
+  const content = formatSummaryMarkdown(summary, sessionId);
+  writeFileSync(filepath, content);
+  return filepath;
+}
+
+export {
+  generateSessionSummary,
+  formatSummaryMarkdown,
+  writeSummaryFile
+};

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,325 @@
+#!/usr/bin/env node
+import {
+  Crystal,
+  resolveConfig
+} from "./chunk-52QE3YI3.js";
+import {
+  ensureLdm,
+  getAgentId,
+  scaffoldLdm
+} from "./chunk-PJ6FFKEX.js";
+
+// src/cli.ts
+import { existsSync, copyFileSync, symlinkSync, lstatSync, unlinkSync } from "fs";
+import { join } from "path";
+var USAGE = `
+crystal \u2014 Sovereign memory system
+
+Commands:
+  crystal search <query> [-n limit] [--agent <id>] [--provider <openai|ollama|google>]
+  crystal remember <text> [--category fact|preference|event|opinion|skill]
+  crystal forget <id>
+  crystal status [--provider <openai|ollama|google>]
+
+  crystal sources add <path> --name <name>    Add a directory for source indexing
+  crystal sources sync <name> [--dry-run]     Sync (re-index changed files)
+  crystal sources status                      Show all indexed collections
+  crystal sources remove <name>               Remove a collection
+
+  crystal init [--agent <id>]                 Scaffold ~/.ldm/ directory tree
+  crystal migrate-db                          Move crystal.db to ~/.ldm/memory/
+
+Environment:
+  CRYSTAL_EMBEDDING_PROVIDER   openai | ollama | google (default: openai)
+  CRYSTAL_OLLAMA_HOST          Ollama URL (default: http://localhost:11434)
+  CRYSTAL_REMOTE_URL           Worker URL for cloud mirror mode
+  CRYSTAL_REMOTE_TOKEN         Auth token for cloud mirror
+  CRYSTAL_AGENT_ID             Agent identifier (default: cc-mini)
+`.trim();
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    console.log(USAGE);
+    process.exit(0);
+  }
+  const command = args[0];
+  const flags = {};
+  let positional = [];
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === "--dry-run") {
+      flags["dry-run"] = "true";
+    } else if (args[i].startsWith("--") || args[i] === "-n") {
+      const key = args[i].replace(/^-+/, "");
+      flags[key] = args[++i] || "";
+    } else {
+      positional.push(args[i]);
+    }
+  }
+  if (command === "init" || command === "migrate-db") {
+    await handleLdmCommand(command, flags);
+    return;
+  }
+  const overrides = {};
+  if (flags.provider) overrides.embeddingProvider = flags.provider;
+  const config = resolveConfig(overrides);
+  const crystal = new Crystal(config);
+  await crystal.init();
+  try {
+    switch (command) {
+      case "search": {
+        const query = positional.join(" ");
+        if (!query) {
+          console.error("Usage: crystal search <query>");
+          process.exit(1);
+        }
+        const limit = parseInt(flags.n || "5", 10);
+        const filter = {};
+        if (flags.agent) filter.agent_id = flags.agent;
+        const results = await crystal.search(query, limit, filter);
+        if (results.length === 0) {
+          console.log("No results found.");
+        } else {
+          for (const r of results) {
+            const score = (r.score * 100).toFixed(1);
+            const date = r.created_at?.slice(0, 10) || "unknown";
+            console.log(`[${score}%] [${r.agent_id}] [${date}] [${r.role}]`);
+            console.log(r.text.slice(0, 300) + (r.text.length > 300 ? "..." : ""));
+            console.log("---");
+          }
+        }
+        break;
+      }
+      case "remember": {
+        const text = positional.join(" ");
+        if (!text) {
+          console.error("Usage: crystal remember <text>");
+          process.exit(1);
+        }
+        const category = flags.category || "fact";
+        const id = await crystal.remember(text, category);
+        console.log(`Remembered (id: ${id}, category: ${category}): ${text}`);
+        break;
+      }
+      case "forget": {
+        const id = parseInt(positional[0], 10);
+        if (isNaN(id)) {
+          console.error("Usage: crystal forget <id>");
+          process.exit(1);
+        }
+        const ok = crystal.forget(id);
+        console.log(ok ? `Forgot memory ${id}` : `Memory ${id} not found or already deprecated`);
+        break;
+      }
+      case "status": {
+        const status = await crystal.status();
+        console.log(`Memory Crystal Status`);
+        console.log(`  Data dir:   ${status.dataDir}`);
+        console.log(`  Provider:   ${status.embeddingProvider}`);
+        console.log(`  Chunks:     ${status.chunks.toLocaleString()}`);
+        console.log(`  Memories:   ${status.memories}`);
+        console.log(`  Sources:    ${status.sources}`);
+        console.log(`  Agents:     ${status.agents.length > 0 ? status.agents.join(", ") : "none yet"}`);
+        break;
+      }
+      case "sources": {
+        const subCommand = positional[0];
+        if (!subCommand) {
+          console.error("Usage: crystal sources <add|sync|status|remove> ...");
+          process.exit(1);
+        }
+        switch (subCommand) {
+          case "add": {
+            const path = positional[1];
+            const name = flags.name;
+            if (!path || !name) {
+              console.error("Usage: crystal sources add <path> --name <name>");
+              process.exit(1);
+            }
+            const col = await crystal.sourcesAdd(path, name);
+            console.log(`Added collection "${col.name}" at ${col.root_path}`);
+            console.log(`Run "crystal sources sync ${name}" to index files.`);
+            break;
+          }
+          case "sync": {
+            const name = positional[1];
+            if (!name) {
+              console.error("Usage: crystal sources sync <name> [--dry-run]");
+              process.exit(1);
+            }
+            const dryRun = "dry-run" in flags;
+            if (dryRun) {
+              console.log(`Dry run for "${name}"...`);
+            } else {
+              console.log(`Syncing "${name}"...`);
+            }
+            const result = await crystal.sourcesSync(name, { dryRun });
+            console.log(`  Added:   ${result.added} files`);
+            console.log(`  Updated: ${result.updated} files`);
+            console.log(`  Removed: ${result.removed} files`);
+            console.log(`  Chunks:  ${result.chunks_added} embedded`);
+            console.log(`  Time:    ${(result.duration_ms / 1e3).toFixed(1)}s`);
+            break;
+          }
+          case "status": {
+            const status = crystal.sourcesStatus();
+            if (status.collections.length === 0) {
+              console.log('No source collections. Use "crystal sources add <path> --name <name>" to add one.');
+            } else {
+              console.log("Source Collections:");
+              for (const col of status.collections) {
+                const syncAgo = col.last_sync_at ? `${Math.round((Date.now() - new Date(col.last_sync_at).getTime()) / 6e4)}m ago` : "never";
+                console.log(`  ${col.name}: ${col.file_count.toLocaleString()} files, ${col.chunk_count.toLocaleString()} chunks, last sync ${syncAgo}`);
+              }
+              console.log(`  Total: ${status.total_files.toLocaleString()} files, ${status.total_chunks.toLocaleString()} chunks`);
+            }
+            break;
+          }
+          case "remove": {
+            const name = positional[1];
+            if (!name) {
+              console.error("Usage: crystal sources remove <name>");
+              process.exit(1);
+            }
+            const ok = crystal.sourcesRemove(name);
+            console.log(ok ? `Removed collection "${name}"` : `Collection "${name}" not found`);
+            break;
+          }
+          default:
+            console.error(`Unknown sources subcommand: ${subCommand}`);
+            process.exit(1);
+        }
+        break;
+      }
+      case "init": {
+        const agentId = flags.agent || getAgentId();
+        const paths = scaffoldLdm(agentId);
+        console.log(`LDM scaffolded for agent "${agentId}"`);
+        console.log(`  Root:         ${paths.root}`);
+        console.log(`  Crystal DB:   ${paths.crystalDb}`);
+        console.log(`  Transcripts:  ${paths.transcripts}`);
+        console.log(`  Sessions:     ${paths.sessions}`);
+        console.log(`  Daily:        ${paths.daily}`);
+        console.log(`  Journals:     ${paths.journals}`);
+        break;
+      }
+      case "migrate-db": {
+        const paths = ensureLdm();
+        const HOME = process.env.HOME || "";
+        const legacyDir = join(HOME, ".openclaw", "memory-crystal");
+        const legacyDb = join(legacyDir, "crystal.db");
+        const destDb = paths.crystalDb;
+        if (!existsSync(legacyDb)) {
+          console.error(`Source not found: ${legacyDb}`);
+          process.exit(1);
+        }
+        if (existsSync(destDb)) {
+          try {
+            const stat = lstatSync(destDb);
+            if (!stat.isSymbolicLink()) {
+              console.error(`Destination already exists (not a symlink): ${destDb}`);
+              console.error("If this is from a previous migration, remove it first.");
+              process.exit(1);
+            }
+          } catch {
+          }
+        }
+        console.log(`Copying ${legacyDb} -> ${destDb}`);
+        copyFileSync(legacyDb, destDb);
+        const Database = (await import("better-sqlite3")).default;
+        const db = new Database(destDb, { readonly: true });
+        const row = db.prepare("SELECT COUNT(*) as count FROM chunks").get();
+        db.close();
+        console.log(`Verified: ${row.count.toLocaleString()} chunks in destination DB`);
+        if (existsSync(legacyDb)) {
+          try {
+            const stat = lstatSync(legacyDb);
+            if (!stat.isSymbolicLink()) {
+              unlinkSync(legacyDb);
+              symlinkSync(destDb, legacyDb);
+              console.log(`Symlinked ${legacyDb} -> ${destDb}`);
+            }
+          } catch (err) {
+            console.error(`Symlink failed (non-fatal): ${err.message}`);
+          }
+        }
+        const legacyLance = join(legacyDir, "lance");
+        if (existsSync(legacyLance)) {
+          try {
+            const stat = lstatSync(legacyLance);
+            if (!stat.isSymbolicLink()) {
+              console.log(`Note: lance/ at ${legacyLance} left in place (LanceDB will use new path on next write)`);
+            }
+          } catch {
+          }
+        }
+        console.log("Migration complete. Restart gateway to use new path.");
+        break;
+      }
+      default:
+        console.error(`Unknown command: ${command}`);
+        console.log(USAGE);
+        process.exit(1);
+    }
+  } finally {
+    crystal.close();
+  }
+}
+async function handleLdmCommand(command, flags) {
+  if (command === "init") {
+    const agentId = flags.agent || getAgentId();
+    const paths = scaffoldLdm(agentId);
+    console.log(`LDM scaffolded for agent "${agentId}"`);
+    console.log(`  Root:         ${paths.root}`);
+    console.log(`  Crystal DB:   ${paths.crystalDb}`);
+    console.log(`  Transcripts:  ${paths.transcripts}`);
+    console.log(`  Sessions:     ${paths.sessions}`);
+    console.log(`  Daily:        ${paths.daily}`);
+    console.log(`  Journals:     ${paths.journals}`);
+    return;
+  }
+  if (command === "migrate-db") {
+    const paths = ensureLdm();
+    const HOME = process.env.HOME || "";
+    const legacyDir = join(HOME, ".openclaw", "memory-crystal");
+    const legacyDb = join(legacyDir, "crystal.db");
+    const destDb = paths.crystalDb;
+    if (!existsSync(legacyDb)) {
+      console.error(`Source not found: ${legacyDb}`);
+      process.exit(1);
+    }
+    if (existsSync(destDb)) {
+      try {
+        const stat = lstatSync(destDb);
+        if (!stat.isSymbolicLink()) {
+          console.error(`Destination already exists (not a symlink): ${destDb}`);
+          console.error("If this is from a previous migration, remove it first.");
+          process.exit(1);
+        }
+      } catch {
+      }
+    }
+    console.log(`Copying ${legacyDb} -> ${destDb}`);
+    copyFileSync(legacyDb, destDb);
+    const Database = (await import("better-sqlite3")).default;
+    const db = new Database(destDb, { readonly: true });
+    const row = db.prepare("SELECT COUNT(*) as count FROM chunks").get();
+    db.close();
+    console.log(`Verified: ${row.count.toLocaleString()} chunks in destination DB`);
+    try {
+      const stat = lstatSync(legacyDb);
+      if (!stat.isSymbolicLink()) {
+        unlinkSync(legacyDb);
+        symlinkSync(destDb, legacyDb);
+        console.log(`Symlinked ${legacyDb} -> ${destDb}`);
+      }
+    } catch (err) {
+      console.error(`Symlink failed (non-fatal): ${err.message}`);
+    }
+    console.log("Migration complete. Restart gateway to use new path.");
+    return;
+  }
+}
+main().catch((err) => {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+});

package/dist/core.d.ts

@@ -0,0 +1,188 @@
+interface CrystalConfig {
+    /** Root directory for all crystal data */
+    dataDir: string;
+    /** Embedding provider: 'openai' | 'ollama' | 'google' */
+    embeddingProvider: 'openai' | 'ollama' | 'google';
+    /** OpenAI API key (required if provider is 'openai') */
+    openaiApiKey?: string;
+    /** OpenAI embedding model (default: text-embedding-3-small) */
+    openaiModel?: string;
+    /** Ollama host (default: http://localhost:11434) */
+    ollamaHost?: string;
+    /** Ollama model (default: nomic-embed-text) */
+    ollamaModel?: string;
+    /** Google API key (required if provider is 'google') */
+    googleApiKey?: string;
+    /** Google embedding model (default: text-embedding-004) */
+    googleModel?: string;
+    /** Remote Worker URL for cloud mirror mode */
+    remoteUrl?: string;
+    /** Remote auth token */
+    remoteToken?: string;
+}
+interface Chunk {
+    id?: number;
+    text: string;
+    embedding?: number[];
+    role: 'user' | 'assistant' | 'system';
+    source_type: string;
+    source_id: string;
+    agent_id: string;
+    token_count: number;
+    created_at: string;
+}
+interface Memory {
+    id?: number;
+    text: string;
+    embedding?: number[];
+    category: 'fact' | 'preference' | 'event' | 'opinion' | 'skill';
+    confidence: number;
+    source_ids: string;
+    status: 'active' | 'deprecated' | 'deleted';
+    created_at: string;
+    updated_at: string;
+}
+interface SearchResult {
+    text: string;
+    role: string;
+    score: number;
+    source_type: string;
+    source_id: string;
+    agent_id: string;
+    created_at: string;
+    freshness?: "fresh" | "recent" | "aging" | "stale";
+}
+interface CrystalStatus {
+    chunks: number;
+    memories: number;
+    sources: number;
+    agents: string[];
+    oldestChunk: string | null;
+    newestChunk: string | null;
+    embeddingProvider: string;
+    dataDir: string;
+    capturedSessions: number;
+    latestCapture: string | null;
+}
+interface SourceCollection {
+    id?: number;
+    name: string;
+    root_path: string;
+    glob_patterns: string;
+    ignore_patterns: string;
+    file_count: number;
+    chunk_count: number;
+    last_sync_at: string | null;
+    created_at: string;
+}
+interface SourceFile {
+    id?: number;
+    collection_id: number;
+    file_path: string;
+    file_hash: string;
+    file_size: number;
+    chunk_count: number;
+    last_indexed_at: string;
+}
+interface SourcesStatus {
+    collections: Array<{
+        name: string;
+        root_path: string;
+        file_count: number;
+        chunk_count: number;
+        last_sync_at: string | null;
+    }>;
+    total_files: number;
+    total_chunks: number;
+}
+interface SyncResult {
+    collection: string;
+    added: number;
+    updated: number;
+    removed: number;
+    chunks_added: number;
+    duration_ms: number;
+}
+declare class Crystal {
+    private config;
+    private lanceDb;
+    private sqliteDb;
+    private chunksTable;
+    private vecDimensions;
+    constructor(config: CrystalConfig);
+    init(): Promise<void>;
+    private initSqliteTables;
+    private initChunksTables;
+    private ensureVecTable;
+    private initLanceTables;
+    embed(texts: string[]): Promise<number[][]>;
+    chunkText(text: string, targetTokens?: number, overlapTokens?: number): string[];
+    ingest(chunks: Chunk[]): Promise<number>;
+    private recencyWeight;
+    private freshnessLabel;
+    search(query: string, limit?: number, filter?: {
+        agent_id?: string;
+        source_type?: string;
+    }): Promise<SearchResult[]>;
+    /** Vector search via sqlite-vec. Two-step pattern: MATCH first, then JOIN. */
+    private searchVec;
+    /** Full-text search via FTS5 with BM25 scoring. */
+    private searchFTS;
+    /** Build a safe FTS5 query from user input. */
+    private buildFTS5Query;
+    /**
+     * Reciprocal Rank Fusion. Ported from QMD (MIT License, Tobi Lutke, 2024-2026).
+     * Fuses multiple ranked result lists into one using RRF scoring.
+     * Uses text content as dedup key (instead of QMD's file path).
+     */
+    private reciprocalRankFusion;
+    /** LanceDB fallback for search (used when sqlite-vec tables are empty, pre-migration). */
+    private searchLanceFallback;
+    remember(text: string, category?: Memory['category']): Promise<number>;
+    forget(memoryId: number): boolean;
+    status(): Promise<CrystalStatus>;
+    getCaptureState(agentId: string, sourceId: string): {
+        lastMessageCount: number;
+        captureCount: number;
+    };
+    setCaptureState(agentId: string, sourceId: string, messageCount: number, captureCount: number): void;
+    private static readonly DEFAULT_INCLUDE;
+    private static readonly DEFAULT_IGNORE;
+    /** Add a directory as a source collection for indexing. */
+    sourcesAdd(rootPath: string, name: string, options?: {
+        include?: string[];
+        ignore?: string[];
+    }): Promise<SourceCollection>;
+    /** Remove a source collection and its file records. Chunks remain in LanceDB. */
+    sourcesRemove(name: string): boolean;
+    /** Sync a collection: scan files, detect changes, re-index what changed. */
+    sourcesSync(name: string, options?: {
+        dryRun?: boolean;
+        batchSize?: number;
+    }): Promise<SyncResult>;
+    /** Get status of all source collections. */
+    sourcesStatus(): SourcesStatus;
+    /** Scan a directory recursively, matching include/ignore patterns. */
+    private scanDirectory;
+    close(): void;
+}
+declare function resolveConfig(overrides?: Partial<CrystalConfig>): CrystalConfig;
+declare class RemoteCrystal {
+    private url;
+    private token;
+    constructor(url: string, token: string);
+    init(): Promise<void>;
+    private request;
+    search(query: string, limit?: number, filter?: {
+        agent_id?: string;
+    }): Promise<SearchResult[]>;
+    ingest(chunks: Chunk[]): Promise<number>;
+    remember(text: string, category?: Memory['category']): Promise<number>;
+    forget(memoryId: number): Promise<boolean>;
+    status(): Promise<CrystalStatus>;
+    chunkText(text: string): string[];
+}
+/** Create the appropriate Crystal instance based on config. */
+declare function createCrystal(config: CrystalConfig): Crystal | RemoteCrystal;
+
+export { type Chunk, Crystal, type CrystalConfig, type CrystalStatus, type Memory, RemoteCrystal, type SearchResult, type SourceCollection, type SourceFile, type SourcesStatus, type SyncResult, createCrystal, resolveConfig };

package/dist/core.js

@@ -0,0 +1,12 @@
+import {
+  Crystal,
+  RemoteCrystal,
+  createCrystal,
+  resolveConfig
+} from "./chunk-52QE3YI3.js";
+export {
+  Crystal,
+  RemoteCrystal,
+  createCrystal,
+  resolveConfig
+};

package/dist/crypto.d.ts

@@ -0,0 +1,16 @@
+declare function loadRelayKey(): Buffer;
+interface EncryptedPayload {
+    v: 1;
+    nonce: string;
+    ciphertext: string;
+    tag: string;
+    hmac: string;
+}
+declare function encrypt(plaintext: Buffer, masterKey: Buffer): EncryptedPayload;
+declare function decrypt(payload: EncryptedPayload, masterKey: Buffer): Buffer;
+declare function encryptJSON(data: unknown, masterKey: Buffer): EncryptedPayload;
+declare function decryptJSON<T = unknown>(payload: EncryptedPayload, masterKey: Buffer): T;
+declare function encryptFile(filePath: string, masterKey: Buffer): EncryptedPayload;
+declare function hashBuffer(data: Buffer): string;
+
+export { type EncryptedPayload, decrypt, decryptJSON, encrypt, encryptFile, encryptJSON, hashBuffer, loadRelayKey };