claude-memory-layer 1.0.11 → 1.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-memory-layer",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "description": "Claude Code plugin that learns from conversations to provide personalized assistance",
   "main": "dist/index.js",
   "bin": {
@@ -42,6 +42,7 @@
     "commander": "^12.0.0",
     "duckdb": "^0.10.0",
     "hono": "^4.0.0",
+    "mongodb": "^6.14.0",
     "zod": "^3.22.0"
   },
   "devDependencies": {

package/scripts/build.ts

@@ -8,6 +8,8 @@ import * as fs from 'fs';
 import * as path from 'path';
 
 const outdir = 'dist';
+const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf-8')) as { version?: string };
+const appVersion = packageJson.version ?? '0.0.0';
 
 // Clean output directory
 if (fs.existsSync(outdir)) {
@@ -30,11 +32,15 @@ const commonOptions: esbuild.BuildOptions = {
     'duckdb',
     'better-sqlite3',
     'commander',
+    'mongodb',
     'zod',
     'hono',
     'hono/cors',
     'hono/logger'
   ],
+  define: {
+    'process.env.CLAUDE_MEMORY_LAYER_VERSION': JSON.stringify(appVersion)
+  },
   banner: {
     js: `import { createRequire } from 'module';
 import { fileURLToPath } from 'url';

package/src/cli/index.ts

@@ -11,10 +11,14 @@ import * as path from 'path';
 import * as os from 'os';
 import {
   getDefaultMemoryService,
-  getMemoryServiceForProject
+  getMemoryServiceForProject,
+  getProjectStoragePath
 } from '../services/memory-service.js';
 import { createSessionHistoryImporter, type ProgressEvent } from '../services/session-history-importer.js';
+import { bootstrapKnowledgeBase } from '../services/bootstrap-organizer.js';
 import { startServer, stopServer, isServerRunning } from '../server/index.js';
+import { SQLiteEventStore } from '../core/sqlite-event-store.js';
+import { MongoSyncWorker } from '../core/mongo-sync-worker.js';
 
 // ============================================================
 // Hook Installation Utilities
@@ -107,7 +111,7 @@ const program = new Command();
 program
   .name('claude-memory-layer')
   .description('Claude Code Memory Plugin CLI')
-  .version('1.0.0');
+  .version(process.env.CLAUDE_MEMORY_LAYER_VERSION || '0.0.0');
 
 // ============================================================
 // Install / Uninstall Commands
@@ -427,6 +431,103 @@ program
     }
   });
 
+/**
+ * Mongo Sync command - sync local SQLite events with a shared MongoDB database (optional)
+ */
+program
+  .command('mongo-sync')
+  .description('Sync events with MongoDB for multi-server collaboration (optional)')
+  .option('-p, --project <path>', 'Project path (defaults to cwd)')
+  .option('--mongo-uri <uri>', 'MongoDB connection URI (env: CLAUDE_MEMORY_MONGO_URI)')
+  .option('--mongo-db <name>', 'MongoDB database name (env: CLAUDE_MEMORY_MONGO_DB)')
+  .option('--mongo-project <key>', 'Remote project key (env: CLAUDE_MEMORY_MONGO_PROJECT, default: basename(projectPath))')
+  .option('--direction <dir>', 'push|pull|both', 'both')
+  .option('--batch-size <n>', 'Batch size', '500')
+  .option('--interval <ms>', 'Watch interval ms', '30000')
+  .option('--watch', 'Run continuously')
+  .action(async (options) => {
+    const projectPath = options.project || process.cwd();
+    const mongoUri = options.mongoUri || process.env.CLAUDE_MEMORY_MONGO_URI;
+    const mongoDb = options.mongoDb || process.env.CLAUDE_MEMORY_MONGO_DB;
+    const projectKey = options.mongoProject || process.env.CLAUDE_MEMORY_MONGO_PROJECT || path.basename(projectPath);
+    const direction = String(options.direction || 'both').toLowerCase();
+
+    if (!mongoUri || !mongoDb) {
+      console.error('\n❌ MongoDB sync is not configured.');
+      console.error('   Set --mongo-uri/--mongo-db or env CLAUDE_MEMORY_MONGO_URI/CLAUDE_MEMORY_MONGO_DB.\n');
+      process.exit(1);
+    }
+
+    if (!['push', 'pull', 'both'].includes(direction)) {
+      console.error('\n❌ Invalid --direction. Use: push | pull | both\n');
+      process.exit(1);
+    }
+
+    const storagePath = getProjectStoragePath(projectPath);
+    if (!fs.existsSync(storagePath)) {
+      fs.mkdirSync(storagePath, { recursive: true });
+    }
+
+    const batchSizeParsed = parseInt(options.batchSize, 10);
+    const intervalParsed = parseInt(options.interval, 10);
+    const batchSize = (Number.isFinite(batchSizeParsed) && batchSizeParsed > 0) ? batchSizeParsed : 500;
+    const intervalMs = (Number.isFinite(intervalParsed) && intervalParsed > 0) ? intervalParsed : 30000;
+
+    const sqliteStore = new SQLiteEventStore(path.join(storagePath, 'events.sqlite'));
+    const worker = new MongoSyncWorker(sqliteStore, {
+      uri: mongoUri,
+      dbName: mongoDb,
+      projectKey,
+      direction,
+      batchSize,
+      intervalMs
+    });
+
+    const runOnce = async () => {
+      const { pushed, pulled } = await worker.syncNow();
+      const ts = new Date().toISOString();
+      process.stdout.write(`[mongo-sync] ${ts} project=${projectKey} pushed=${pushed} pulled=${pulled}\n`);
+    };
+
+    try {
+      if (!options.watch) {
+        await runOnce();
+        await worker.shutdown();
+        sqliteStore.close();
+        return;
+      }
+
+      console.log(`[mongo-sync] Watch mode started (interval=${intervalMs}ms, project=${projectKey})`);
+
+      const handle = setInterval(() => {
+        runOnce().catch((err) => {
+          console.error('[mongo-sync] Sync failed:', err);
+        });
+      }, intervalMs);
+
+      const shutdown = async () => {
+        clearInterval(handle);
+        console.log('\n[mongo-sync] Shutting down...');
+        try {
+          await worker.shutdown();
+        } finally {
+          sqliteStore.close();
+        }
+        process.exit(0);
+      };
+
+      process.on('SIGINT', () => { void shutdown(); });
+      process.on('SIGTERM', () => { void shutdown(); });
+
+      // Run immediately, then keep alive
+      await runOnce();
+      await new Promise(() => {});
+    } catch (error) {
+      console.error('[mongo-sync] Failed:', error);
+      process.exit(1);
+    }
+  });
+
 /**
  * Render import progress to terminal
  */
@@ -502,6 +603,184 @@ function printImportSummary(result: import('../services/session-history-importer
   }
 }
 
+function sanitizeSegment(input: string | undefined, fallback: string): string {
+  const v = (input || '').trim().toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+  return v || fallback;
+}
+
+async function listMarkdownFiles(root: string): Promise<string[]> {
+  const out: string[] = [];
+  const stack = [root];
+
+  while (stack.length > 0) {
+    const dir = stack.pop()!;
+    const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+    for (const e of entries) {
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) stack.push(full);
+      else if (e.isFile() && e.name.endsWith('.md') && e.name !== '_index.md') out.push(full);
+    }
+  }
+
+  return out.sort();
+}
+
+function deriveNamespaceCategory(sourceRoot: string, filePath: string): { namespace: string; categoryPath: string[] } {
+  const rel = path.relative(sourceRoot, filePath);
+  const dirSeg = path.dirname(rel).split(path.sep).filter(Boolean);
+
+  if (dirSeg.length >= 2) {
+    const namespace = sanitizeSegment(dirSeg[0], 'default');
+    const categoryPath = dirSeg.slice(1).map((s) => sanitizeSegment(s, 'uncategorized'));
+    return { namespace, categoryPath: categoryPath.length > 0 ? categoryPath : ['uncategorized'] };
+  }
+
+  return { namespace: 'default', categoryPath: ['uncategorized'] };
+}
+
+function extractImportEvidence(markdown: string): { confidence?: string; sources: string[] } {
+  const confidenceMatch = markdown.match(/^-\s*confidence:\s*([^\n]+)/m);
+  const sources = markdown
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith('- source:'))
+    .map((line) => line.replace(/^-\s*source:\s*/i, '').trim())
+    .filter(Boolean)
+    .slice(0, 30);
+
+  return {
+    confidence: confidenceMatch ? confidenceMatch[1].trim() : undefined,
+    sources
+  };
+}
+
+/**
+ * Organize-import command - import legacy markdown memories into structured mirror
+ */
+program
+  .command('organize-import [sourceDir]')
+  .description('Import existing markdown memory files, or bootstrap knowledge docs from codebase/git when markdown is missing')
+  .option('-p, --project <path>', 'Project path (defaults to cwd)')
+  .option('--session <id>', 'Session id for imported events (default: import:organized)')
+  .option('--limit <n>', 'Limit number of files to import')
+  .option('--dry-run', 'Preview mapping without writing')
+  .option('--bootstrap', 'Force-generate structured markdown from codebase + git history before import')
+  .option('--bootstrap-if-empty', 'Auto-bootstrap when source has no markdown files (default: true)', true)
+  .option('--no-bootstrap-if-empty', 'Disable auto-bootstrap when source has no markdown files')
+  .option('--force-bootstrap', 'Run bootstrap even when markdown files exist')
+  .option('--repo <path>', 'Repository root for bootstrap analysis (default: project path)')
+  .option('--out <path>', 'Output directory for generated bootstrap markdown (default: <sourceDir>/bootstrap-kb)')
+  .option('--since <range>', 'Git history range for bootstrap (default: "180 days ago")')
+  .option('--max-commits <n>', 'Max commits to analyze for bootstrap (default: 1000)')
+  .option('--incremental', 'Use previous bootstrap manifest as baseline for incremental updates (default: true)', true)
+  .option('--no-incremental', 'Disable incremental bootstrap; regenerate full snapshot')
+  .action(async (sourceDir: string | undefined, options) => {
+    const projectPath = options.project || process.cwd();
+    const sessionId = options.session || 'import:organized';
+    const sourceRoot = path.resolve(sourceDir || options.out || projectPath);
+    const repoPath = path.resolve(options.repo || projectPath);
+
+    if (!fs.existsSync(sourceRoot)) {
+      fs.mkdirSync(sourceRoot, { recursive: true });
+    }
+
+    const service = getMemoryServiceForProject(projectPath);
+
+    try {
+      let activeSourceRoot = sourceRoot;
+      let importRoot = sourceRoot;
+      let files = await listMarkdownFiles(importRoot);
+      const hasMarkdown = files.length > 0;
+      const shouldBootstrap = Boolean(options.forceBootstrap || options.bootstrap || (!hasMarkdown && options.bootstrapIfEmpty));
+
+      if (shouldBootstrap) {
+        const outDir = path.resolve(options.out || path.join(sourceRoot, 'bootstrap-kb'));
+        const since = options.since || '180 days ago';
+        const maxCommits = options.maxCommits ? Math.max(1, parseInt(options.maxCommits, 10)) : 1000;
+
+        console.log('\n🧠 Bootstrapping markdown knowledge base...');
+        const bootstrap = await bootstrapKnowledgeBase({
+          repoPath,
+          outDir,
+          since,
+          maxCommits,
+          incremental: options.incremental
+        });
+        console.log(`  Repo: ${repoPath}`);
+        console.log(`  Output: ${bootstrap.outDir}`);
+        console.log(`  Files analyzed: ${bootstrap.fileCount}`);
+        console.log(`  Commits analyzed: ${bootstrap.commitCount}`);
+        console.log(`  Modules: ${bootstrap.moduleCount}`);
+
+        activeSourceRoot = outDir;
+        importRoot = outDir;
+        files = await listMarkdownFiles(importRoot);
+      }
+
+      if (files.length === 0) {
+        console.error('\n❌ organize-import found no markdown files to import.\n');
+        process.exit(1);
+      }
+
+      const limit = options.limit ? Math.max(1, parseInt(options.limit, 10)) : files.length;
+      const targets = files.slice(0, limit);
+
+      console.log(`\n📦 organize-import`);
+      console.log(`  Source: ${activeSourceRoot}`);
+      console.log(`  Project: ${projectPath}`);
+      console.log(`  Files: ${targets.length}${targets.length < files.length ? `/${files.length}` : ''}`);
+      console.log(`  Dry-run: ${options.dryRun ? 'yes' : 'no'}\n`);
+
+      if (!options.dryRun) {
+        await service.initialize();
+      }
+
+      let imported = 0;
+      let skipped = 0;
+
+      for (const file of targets) {
+        const text = await fs.promises.readFile(file, 'utf8');
+        if (!text.trim()) {
+          skipped += 1;
+          continue;
+        }
+
+        const { namespace, categoryPath } = deriveNamespaceCategory(activeSourceRoot, file);
+        const rel = path.relative(activeSourceRoot, file);
+        const evidence = extractImportEvidence(text);
+
+        if (options.dryRun) {
+          console.log(`- ${rel} -> namespace=${namespace} category=${categoryPath.join('/')} confidence=${evidence.confidence || 'n/a'} sources=${evidence.sources.length}`);
+          continue;
+        }
+
+        await service.storeSessionSummary(sessionId, text, {
+          namespace,
+          categoryPath,
+          confidence: evidence.confidence,
+          sources: evidence.sources,
+          import: {
+            sourceFile: rel,
+            importedAt: new Date().toISOString(),
+            bootstrap: shouldBootstrap === true
+          }
+        });
+        imported += 1;
+      }
+
+      if (!options.dryRun) {
+        const embed = await service.processPendingEmbeddings();
+        await service.shutdown();
+        console.log(`\n✅ Imported: ${imported}, skipped-empty: ${skipped}, embeddings: ${embed}\n`);
+      } else {
+        console.log(`\n✅ Dry-run complete (planned imports: ${targets.length - skipped}, skipped-empty: ${skipped})\n`);
+      }
+    } catch (error) {
+      console.error('\n❌ organize-import failed:', error);
+      process.exit(1);
+    }
+  });
+
 /**
  * Import command - import existing Claude Code sessions
  */

package/src/core/consolidated-store.ts

@@ -8,7 +8,9 @@ import { randomUUID } from 'crypto';
 import { dbRun, dbAll, toDate, type Database } from './db-wrapper.js';
 import type {
   ConsolidatedMemory,
-  ConsolidatedMemoryInput
+  ConsolidatedMemoryInput,
+  ConsolidationRule,
+  ConsolidationRuleInput
 } from './types.js';
 import { EventStore } from './event-store.js';
 
@@ -170,6 +172,66 @@ export class ConsolidatedStore {
     );
   }
 
+  /**
+   * Create a long-term rule promoted from stable summaries
+   */
+  async createRule(input: ConsolidationRuleInput): Promise<string> {
+    const ruleId = randomUUID();
+
+    await dbRun(
+      this.db,
+      `INSERT INTO consolidated_rules
+        (rule_id, rule, topics, source_memory_ids, source_events, confidence, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`,
+      [
+        ruleId,
+        input.rule,
+        JSON.stringify(input.topics),
+        JSON.stringify(input.sourceMemoryIds),
+        JSON.stringify(input.sourceEvents),
+        input.confidence
+      ]
+    );
+
+    return ruleId;
+  }
+
+  async getRules(options?: { limit?: number }): Promise<ConsolidationRule[]> {
+    const limit = options?.limit || 100;
+    const rows = await dbAll<Record<string, unknown>>(
+      this.db,
+      `SELECT * FROM consolidated_rules ORDER BY confidence DESC, created_at DESC LIMIT ?`,
+      [limit]
+    );
+
+    return rows.map((row) => ({
+      ruleId: row.rule_id as string,
+      rule: row.rule as string,
+      topics: JSON.parse((row.topics as string) || '[]'),
+      sourceMemoryIds: JSON.parse((row.source_memory_ids as string) || '[]'),
+      sourceEvents: JSON.parse((row.source_events as string) || '[]'),
+      confidence: Number(row.confidence ?? 0.5),
+      createdAt: toDate(row.created_at) || new Date()
+    }));
+  }
+
+  async countRules(): Promise<number> {
+    const result = await dbAll<{ count: number }>(
+      this.db,
+      `SELECT COUNT(*) as count FROM consolidated_rules`
+    );
+    return result[0]?.count || 0;
+  }
+
+  async hasRuleForSourceMemory(memoryId: string): Promise<boolean> {
+    const rows = await dbAll<{ count: number }>(
+      this.db,
+      `SELECT COUNT(*) as count FROM consolidated_rules WHERE source_memory_ids LIKE ?`,
+      [`%"${memoryId}"%`]
+    );
+    return (rows[0]?.count || 0) > 0;
+  }
+
   /**
    * Get count of consolidated memories
    */

package/src/core/consolidation-worker.ts

@@ -8,7 +8,8 @@ import type {
   EndlessModeConfig,
   MemoryEvent,
   EventGroup,
-  WorkingSet
+  WorkingSet,
+  ConsolidationCostQualityReport
 } from './types.js';
 import { WorkingSetStore } from './working-set-store.js';
 import { ConsolidatedStore } from './consolidated-store.js';
@@ -62,7 +63,19 @@ export class ConsolidationWorker {
    * Force a consolidation run (manual trigger)
    */
   async forceRun(): Promise<number> {
-    return await this.consolidate();
+    const out = await this.consolidateWithReport();
+    return out.consolidatedCount;
+  }
+
+  /**
+   * Force a consolidation run and return metrics report
+   */
+  async forceRunWithReport(): Promise<{
+    consolidatedCount: number;
+    promotedRuleCount: number;
+    report: ConsolidationCostQualityReport;
+  }> {
+    return this.consolidateWithReport();
   }
 
   /**
@@ -109,15 +122,29 @@ export class ConsolidationWorker {
    * Perform consolidation
    */
   private async consolidate(): Promise<number> {
+    const out = await this.consolidateWithReport();
+    return out.consolidatedCount;
+  }
+
+  private async consolidateWithReport(): Promise<{
+    consolidatedCount: number;
+    promotedRuleCount: number;
+    report: ConsolidationCostQualityReport;
+  }> {
     const workingSet = await this.workingSetStore.get();
 
     if (workingSet.recentEvents.length < 3) {
-      return 0; // Not enough events to consolidate
+      return {
+        consolidatedCount: 0,
+        promotedRuleCount: 0,
+        report: this.buildCostQualityReport(workingSet.recentEvents, [], 0)
+      };
     }
 
     // Group events by topic
     const groups = this.groupByTopic(workingSet.recentEvents);
     let consolidatedCount = 0;
+    const createdMemoryIds: string[] = [];
 
     for (const group of groups) {
       // Require minimum 3 events per group
@@ -132,16 +159,18 @@ export class ConsolidationWorker {
       const summary = await this.summarize(group);
 
       // Create consolidated memory
-      await this.consolidatedStore.create({
+      const memoryId = await this.consolidatedStore.create({
         summary,
         topics: group.topics,
         sourceEvents: eventIds,
         confidence: this.calculateConfidence(group)
       });
-
+      createdMemoryIds.push(memoryId);
       consolidatedCount++;
     }
 
+    const promotedRuleCount = await this.promoteStableSummariesToRules(createdMemoryIds);
+
     // Prune consolidated events from working set
     if (consolidatedCount > 0) {
       const consolidatedEventIds = groups
@@ -161,7 +190,87 @@ export class ConsolidationWorker {
       }
     }
 
-    return consolidatedCount;
+    const report = this.buildCostQualityReport(workingSet.recentEvents, groups, consolidatedCount);
+    return { consolidatedCount, promotedRuleCount, report };
+  }
+
+  private async promoteStableSummariesToRules(memoryIds: string[]): Promise<number> {
+    let promoted = 0;
+
+    for (const memoryId of memoryIds) {
+      const memory = await this.consolidatedStore.get(memoryId);
+      if (!memory) continue;
+      if (memory.confidence < 0.55) continue;
+      if (memory.sourceEvents.length < 4) continue;
+
+      const exists = await this.consolidatedStore.hasRuleForSourceMemory(memoryId);
+      if (exists) continue;
+
+      const rule = this.buildRuleFromSummary(memory.summary, memory.topics);
+      if (!rule) continue;
+
+      await this.consolidatedStore.createRule({
+        rule,
+        topics: memory.topics,
+        sourceMemoryIds: [memory.memoryId],
+        sourceEvents: memory.sourceEvents,
+        confidence: Math.min(1, memory.confidence + 0.08)
+      });
+      promoted++;
+    }
+
+    return promoted;
+  }
+
+  private buildRuleFromSummary(summary: string, topics: string[]): string | null {
+    const lines = summary
+      .split(/\r?\n/)
+      .map((l) => l.trim())
+      .filter(Boolean)
+      .filter((l) => !l.toLowerCase().startsWith('topics:'));
+
+    const bullet = lines.find((l) => l.startsWith('- '))?.replace(/^-\s*/, '');
+    const seed = bullet || lines[0];
+    if (!seed || seed.length < 8) return null;
+
+    const topicPrefix = topics.length > 0 ? `[${topics.slice(0, 2).join(', ')}] ` : '';
+    return `${topicPrefix}${seed}`;
+  }
+
+  private buildCostQualityReport(
+    events: MemoryEvent[],
+    groups: EventGroup[],
+    consolidatedCount: number
+  ): ConsolidationCostQualityReport {
+    const beforeTokenEstimate = events.reduce((acc, e) => acc + this.estimateTokens(e.content), 0);
+
+    const afterSummaries = groups
+      .filter((g) => g.events.length >= 3)
+      .slice(0, Math.max(consolidatedCount, 1));
+
+    const afterTokenEstimate = afterSummaries.length > 0
+      ? afterSummaries.reduce((acc, g) => acc + this.estimateTokens(this.ruleBasedSummary(g)), 0)
+      : beforeTokenEstimate;
+
+    const reductionRatio = beforeTokenEstimate > 0
+      ? Math.max(0, (beforeTokenEstimate - afterTokenEstimate) / beforeTokenEstimate)
+      : 0;
+
+    const qualityGuardPassed = consolidatedCount === 0
+      ? true
+      : groups.filter((g) => g.events.length >= 3).every((g) => this.calculateConfidence(g) >= 0.55);
+
+    return {
+      beforeTokenEstimate,
+      afterTokenEstimate,
+      reductionRatio,
+      qualityGuardPassed,
+      details: `groups=${groups.length}, consolidated=${consolidatedCount}`
+    };
+  }
+
+  private estimateTokens(text: string): number {
+    return Math.ceil((text || '').length / 4);
   }
 
   /**

package/src/core/event-store.ts

@@ -280,6 +280,19 @@ export class EventStore {
       )
     `);
 
+    // Consolidated Rules table (long-term stable memory)
+    await dbRun(this.db, `
+      CREATE TABLE IF NOT EXISTS consolidated_rules (
+        rule_id VARCHAR PRIMARY KEY,
+        rule TEXT NOT NULL,
+        topics JSON,
+        source_memory_ids JSON,
+        source_events JSON,
+        confidence FLOAT DEFAULT 0.5,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+
     // Endless Mode Config table
     await dbRun(this.db, `
       CREATE TABLE IF NOT EXISTS endless_config (
@@ -314,6 +327,7 @@ export class EventStore {
     await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_working_set_expires ON working_set(expires_at)`);
     await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_working_set_relevance ON working_set(relevance_score DESC)`);
     await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_consolidated_confidence ON consolidated_memories(confidence DESC)`);
+    await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_consolidated_rules_confidence ON consolidated_rules(confidence DESC)`);
     await dbRun(this.db, `CREATE INDEX IF NOT EXISTS idx_continuity_created ON continuity_log(created_at)`);
 
     this.initialized = true;

package/src/core/index.ts

@@ -14,6 +14,7 @@ export * from './event-store.js';
 export * from './sqlite-wrapper.js';
 export * from './sqlite-event-store.js';
 export * from './sync-worker.js';
+export * from './mongo-sync-worker.js';
 export * from './entity-repo.js';
 export * from './edge-repo.js';