@weavelogic/knowledge-graph-agent 0.2.0 → 0.4.0

package/dist/memory/vault-sync.js

@@ -0,0 +1,463 @@
+import { createHash } from "crypto";
+import { createLogger } from "../utils/logger.js";
+import { ShadowCache } from "../core/cache.js";
+const logger = createLogger("vault-sync");
+class VaultMemorySync {
+  options;
+  shadowCache;
+  db = null;
+  memoryCache = /* @__PURE__ */ new Map();
+  conflicts = [];
+  lastSyncTime = null;
+  isSyncing = false;
+  syncErrors = [];
+  autoSyncTimer = null;
+  constructor(options) {
+    this.options = {
+      projectRoot: options.projectRoot,
+      namespace: options.namespace ?? "knowledge-graph",
+      conflictStrategy: options.conflictStrategy ?? "newest-wins",
+      autoSync: options.autoSync ?? false,
+      autoSyncInterval: options.autoSyncInterval ?? 3e5,
+      // 5 minutes
+      retryOptions: options.retryOptions ?? { maxRetries: 3, initialDelay: 1e3 },
+      batchSize: options.batchSize ?? 50,
+      includeContent: options.includeContent ?? false,
+      maxContentLength: options.maxContentLength ?? 5e3
+    };
+    this.shadowCache = new ShadowCache({
+      projectRoot: options.projectRoot,
+      cacheDir: ".kg/sync-cache"
+    });
+  }
+  /**
+   * Initialize the sync system with database
+   */
+  async initialize(db) {
+    this.db = db;
+    await this.shadowCache.load();
+    await this.loadMemoryCache();
+    if (this.options.autoSync) {
+      this.startAutoSync();
+    }
+    logger.info("Vault sync initialized", {
+      namespace: this.options.namespace,
+      autoSync: this.options.autoSync
+    });
+  }
+  /**
+   * Sync knowledge graph to claude-flow memory
+   */
+  async syncToMemory() {
+    if (!this.db) {
+      throw new Error("Database not initialized. Call initialize() first.");
+    }
+    const startTime = Date.now();
+    const result = {
+      success: true,
+      synced: 0,
+      skipped: 0,
+      failed: 0,
+      conflicts: [],
+      errors: [],
+      duration: 0
+    };
+    this.isSyncing = true;
+    this.syncErrors = [];
+    try {
+      const nodes = this.db.getAllNodes();
+      const batches = this.createBatches(nodes, this.options.batchSize);
+      for (const batch of batches) {
+        for (const node of batch) {
+          try {
+            const memoryNode = this.nodeToMemoryEntry(node);
+            const cached = this.memoryCache.get(node.id);
+            if (cached && cached.contentHash !== memoryNode.contentHash) {
+              const conflict = await this.detectConflict(node, cached);
+              if (conflict) {
+                result.conflicts.push(conflict);
+                const resolved = await this.resolveConflict(conflict);
+                if (!resolved) {
+                  result.skipped++;
+                  continue;
+                }
+              }
+            }
+            await this.storeToMemory(memoryNode);
+            this.memoryCache.set(node.id, memoryNode);
+            result.synced++;
+          } catch (error) {
+            result.failed++;
+            result.errors.push({
+              nodeId: node.id,
+              error: String(error)
+            });
+            this.syncErrors.push(`Failed to sync ${node.id}: ${error}`);
+          }
+        }
+      }
+      await this.syncIndexesToMemory(nodes);
+      result.duration = Date.now() - startTime;
+      result.success = result.failed === 0;
+      this.lastSyncTime = /* @__PURE__ */ new Date();
+      logger.info("Sync to memory completed", {
+        synced: result.synced,
+        failed: result.failed,
+        duration: result.duration
+      });
+    } finally {
+      this.isSyncing = false;
+      await this.saveMemoryCache();
+    }
+    return result;
+  }
+  /**
+   * Sync from claude-flow memory to knowledge graph
+   */
+  async syncFromMemory() {
+    if (!this.db) {
+      throw new Error("Database not initialized. Call initialize() first.");
+    }
+    const startTime = Date.now();
+    const result = {
+      success: true,
+      synced: 0,
+      skipped: 0,
+      failed: 0,
+      conflicts: [],
+      errors: [],
+      duration: 0
+    };
+    this.isSyncing = true;
+    this.syncErrors = [];
+    try {
+      const memoryNodes = await this.retrieveFromMemory();
+      for (const memoryNode of memoryNodes) {
+        try {
+          const existingNode = this.db.getNode(memoryNode.id);
+          if (existingNode) {
+            const currentHash = this.computeContentHash(existingNode.content);
+            if (currentHash !== memoryNode.contentHash) {
+              const conflict = this.createConflictRecord(existingNode, memoryNode);
+              result.conflicts.push(conflict);
+              const resolved = await this.resolveConflict(conflict);
+              if (!resolved || conflict.resolvedAs === "vault") {
+                result.skipped++;
+                continue;
+              }
+            }
+          }
+          result.synced++;
+          this.memoryCache.set(memoryNode.id, memoryNode);
+        } catch (error) {
+          result.failed++;
+          result.errors.push({
+            nodeId: memoryNode.id,
+            error: String(error)
+          });
+        }
+      }
+      result.duration = Date.now() - startTime;
+      result.success = result.failed === 0;
+      this.lastSyncTime = /* @__PURE__ */ new Date();
+      logger.info("Sync from memory completed", {
+        synced: result.synced,
+        failed: result.failed,
+        duration: result.duration
+      });
+    } finally {
+      this.isSyncing = false;
+      await this.saveMemoryCache();
+    }
+    return result;
+  }
+  /**
+   * Perform full bidirectional sync
+   */
+  async fullSync() {
+    const startTime = Date.now();
+    const toMemory = await this.syncToMemory();
+    const fromMemory = await this.syncFromMemory();
+    return {
+      success: toMemory.success && fromMemory.success,
+      toMemory,
+      fromMemory,
+      totalDuration: Date.now() - startTime,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Get current sync status
+   */
+  getStatus() {
+    const pendingVaultChanges = this.db ? this.countPendingVaultChanges() : 0;
+    const pendingMemoryChanges = this.countPendingMemoryChanges();
+    let health = "healthy";
+    if (this.syncErrors.length > 0) {
+      health = "error";
+    } else if (this.conflicts.length > 0 || pendingVaultChanges > 10) {
+      health = "warning";
+    }
+    return {
+      lastSync: this.lastSyncTime,
+      isSyncing: this.isSyncing,
+      pendingVaultChanges,
+      pendingMemoryChanges,
+      errors: [...this.syncErrors],
+      health
+    };
+  }
+  /**
+   * Get unresolved conflicts
+   */
+  getConflicts() {
+    return this.conflicts.filter((c) => !c.resolvedAt);
+  }
+  /**
+   * Manually resolve a conflict
+   */
+  async resolveConflictManually(nodeId, resolution) {
+    const conflict = this.conflicts.find(
+      (c) => c.nodeId === nodeId && !c.resolvedAt
+    );
+    if (!conflict) {
+      return false;
+    }
+    conflict.resolvedAs = resolution;
+    conflict.resolvedAt = /* @__PURE__ */ new Date();
+    if (resolution === "vault" && this.db) {
+      const node = this.db.getNode(nodeId);
+      if (node) {
+        const memoryNode = this.nodeToMemoryEntry(node);
+        await this.storeToMemory(memoryNode);
+        this.memoryCache.set(nodeId, memoryNode);
+      }
+    }
+    return true;
+  }
+  /**
+   * Detect changes in vault since last sync
+   */
+  async detectChanges() {
+    if (!this.db) {
+      return [];
+    }
+    const nodes = this.db.getAllNodes();
+    const filePaths = nodes.map((n) => n.path);
+    return this.shadowCache.detectChanges(filePaths);
+  }
+  /**
+   * Stop the sync system
+   */
+  stop() {
+    if (this.autoSyncTimer) {
+      clearInterval(this.autoSyncTimer);
+      this.autoSyncTimer = null;
+    }
+    this.saveMemoryCache().catch(
+      (err) => logger.error("Failed to save memory cache on stop", err)
+    );
+  }
+  // Private methods
+  startAutoSync() {
+    if (this.autoSyncTimer) {
+      clearInterval(this.autoSyncTimer);
+    }
+    this.autoSyncTimer = setInterval(async () => {
+      if (!this.isSyncing) {
+        try {
+          await this.syncToMemory();
+        } catch (error) {
+          logger.error("Auto-sync failed", error);
+        }
+      }
+    }, this.options.autoSyncInterval);
+  }
+  nodeToMemoryEntry(node) {
+    const summary = this.extractSummary(node.content);
+    const contentHash = this.computeContentHash(node.content);
+    return {
+      id: node.id,
+      title: node.title,
+      type: node.type,
+      status: node.status,
+      path: node.path,
+      tags: node.tags,
+      outgoingLinks: node.outgoingLinks.map((l) => l.target),
+      incomingLinks: node.incomingLinks.map((l) => l.target),
+      summary,
+      contentHash,
+      lastModified: node.lastModified.toISOString(),
+      syncedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  extractSummary(content, maxLength = 200) {
+    const lines = content.split("\n");
+    let summary = "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("```") || trimmed === "---") {
+        continue;
+      }
+      summary = trimmed;
+      break;
+    }
+    if (summary.length > maxLength) {
+      summary = summary.slice(0, maxLength - 3) + "...";
+    }
+    return summary;
+  }
+  computeContentHash(content) {
+    return createHash("md5").update(content).digest("hex").substring(0, 16);
+  }
+  async storeToMemory(node) {
+    logger.debug("Store to memory", {
+      key: `node/${node.id}`,
+      namespace: this.options.namespace
+    });
+  }
+  async retrieveFromMemory() {
+    logger.debug("Retrieve from memory", {
+      namespace: this.options.namespace
+    });
+    return Array.from(this.memoryCache.values());
+  }
+  async syncIndexesToMemory(nodes) {
+    const nodeIndex = nodes.map((n) => ({
+      id: n.id,
+      title: n.title,
+      type: n.type,
+      path: n.path
+    }));
+    logger.debug("Sync node index", {
+      count: nodeIndex.length,
+      namespace: this.options.namespace
+    });
+    const tagIndex = {};
+    for (const node of nodes) {
+      for (const tag of node.tags) {
+        if (!tagIndex[tag]) {
+          tagIndex[tag] = [];
+        }
+        tagIndex[tag].push(node.id);
+      }
+    }
+    logger.debug("Sync tag index", {
+      tags: Object.keys(tagIndex).length,
+      namespace: this.options.namespace
+    });
+    const metadata = {
+      lastSync: (/* @__PURE__ */ new Date()).toISOString(),
+      nodeCount: nodes.length,
+      namespace: this.options.namespace
+    };
+    logger.debug("Sync metadata", metadata);
+  }
+  async detectConflict(node, cached) {
+    const vaultHash = this.computeContentHash(node.content);
+    if (vaultHash === cached.contentHash) {
+      return null;
+    }
+    return {
+      nodeId: node.id,
+      path: node.path,
+      vaultVersion: {
+        hash: vaultHash,
+        modifiedAt: node.lastModified,
+        content: this.options.includeContent ? node.content : void 0
+      },
+      memoryVersion: {
+        hash: cached.contentHash,
+        modifiedAt: new Date(cached.lastModified)
+      }
+    };
+  }
+  createConflictRecord(node, memoryNode) {
+    return {
+      nodeId: node.id,
+      path: node.path,
+      vaultVersion: {
+        hash: this.computeContentHash(node.content),
+        modifiedAt: node.lastModified
+      },
+      memoryVersion: {
+        hash: memoryNode.contentHash,
+        modifiedAt: new Date(memoryNode.lastModified)
+      }
+    };
+  }
+  async resolveConflict(conflict) {
+    switch (this.options.conflictStrategy) {
+      case "vault-wins":
+        conflict.resolvedAs = "vault";
+        conflict.resolvedAt = /* @__PURE__ */ new Date();
+        return true;
+      case "memory-wins":
+        conflict.resolvedAs = "memory";
+        conflict.resolvedAt = /* @__PURE__ */ new Date();
+        return true;
+      case "newest-wins":
+        if (conflict.vaultVersion.modifiedAt > conflict.memoryVersion.modifiedAt) {
+          conflict.resolvedAs = "vault";
+        } else {
+          conflict.resolvedAs = "memory";
+        }
+        conflict.resolvedAt = /* @__PURE__ */ new Date();
+        return true;
+      case "merge":
+        if (conflict.vaultVersion.modifiedAt > conflict.memoryVersion.modifiedAt) {
+          conflict.resolvedAs = "vault";
+        } else {
+          conflict.resolvedAs = "memory";
+        }
+        conflict.resolvedAt = /* @__PURE__ */ new Date();
+        return true;
+      case "manual":
+        this.conflicts.push(conflict);
+        return false;
+      default:
+        return false;
+    }
+  }
+  countPendingVaultChanges() {
+    const cachedHashes = /* @__PURE__ */ new Map();
+    for (const [id, node] of this.memoryCache) {
+      cachedHashes.set(id, node.contentHash);
+    }
+    let pending = 0;
+    const nodes = this.db?.getAllNodes() ?? [];
+    for (const node of nodes) {
+      const cachedHash = cachedHashes.get(node.id);
+      const currentHash = this.computeContentHash(node.content);
+      if (!cachedHash || cachedHash !== currentHash) {
+        pending++;
+      }
+    }
+    return pending;
+  }
+  countPendingMemoryChanges() {
+    return 0;
+  }
+  createBatches(items, batchSize) {
+    const batches = [];
+    for (let i = 0; i < items.length; i += batchSize) {
+      batches.push(items.slice(i, i + batchSize));
+    }
+    return batches;
+  }
+  async loadMemoryCache() {
+    logger.debug("Loading memory cache");
+  }
+  async saveMemoryCache() {
+    await this.shadowCache.save();
+    logger.debug("Memory cache saved");
+  }
+}
+function createVaultMemorySync(options) {
+  return new VaultMemorySync(options);
+}
+export {
+  VaultMemorySync,
+  createVaultMemorySync
+};
+//# sourceMappingURL=vault-sync.js.map

package/dist/memory/vault-sync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vault-sync.js","sources":["../../src/memory/vault-sync.ts"],"sourcesContent":["/**\n * Vault Memory Sync\n *\n * Provides bidirectional synchronization between the knowledge graph\n * and claude-flow memory system for persistent agent coordination.\n *\n * @module memory/vault-sync\n */\n\nimport { createHash } from 'crypto';\nimport { createLogger, withRetry, type RetryOptions } from '../utils/index.js';\nimport { ShadowCache, type FileMetadata, type FileChange } from '../core/cache.js';\nimport type { KnowledgeNode, GraphStats, SyncResult } from '../core/types.js';\nimport { KnowledgeGraphDatabase } from '../core/database.js';\n\nconst logger = createLogger('vault-sync');\n\n/**\n * Sync direction\n */\nexport type SyncDirection = 'to-memory' | 'from-memory' | 'bidirectional';\n\n/**\n * Conflict resolution strategy\n */\nexport type ConflictStrategy =\n  | 'memory-wins'    // Memory version takes precedence\n  | 'vault-wins'     // Vault version takes precedence\n  | 'newest-wins'    // Most recently modified wins\n  | 'merge'          // Attempt to merge changes\n  | 'manual';        // Require manual resolution\n\n/**\n * Sync status\n */\nexport interface SyncStatus {\n  /** Last successful sync timestamp */\n  lastSync: Date | null;\n  /** Whether sync is currently running */\n  isSyncing: boolean;\n  /** Number of pending changes in vault */\n  pendingVaultChanges: number;\n  /** Number of pending changes in memory */\n  pendingMemoryChanges: number;\n  /** Any sync errors */\n  errors: string[];\n  /** Sync health status */\n  health: 'healthy' | 'warning' | 'error';\n}\n\n/**\n * Memory entry format for claude-flow\n */\nexport interface MemoryNode {\n  id: string;\n  title: string;\n  type: string;\n  status: string;\n  path: string;\n  tags: string[];\n  outgoingLinks: string[];\n  incomingLinks: string[];\n  summary: string;\n  contentHash: string;\n  lastModified: string;\n  syncedAt: string;\n}\n\n/**\n * Conflict record\n */\nexport interface SyncConflict {\n  nodeId: string;\n  path: string;\n  vaultVersion: {\n    hash: string;\n    modifiedAt: Date;\n    content?: string;\n  };\n  memoryVersion: {\n    hash: string;\n    modifiedAt: Date;\n    content?: string;\n  };\n  resolvedAs?: 'vault' | 'memory' | 'merged';\n  resolvedAt?: Date;\n}\n\n/**\n * Sync options\n */\nexport interface VaultSyncOptions {\n  /** Project root directory */\n  projectRoot: string;\n  /** Claude-flow memory namespace */\n  namespace?: string;\n  /** Conflict resolution strategy */\n  conflictStrategy?: ConflictStrategy;\n  /** Whether to auto-sync on changes */\n  autoSync?: boolean;\n  /** Auto-sync interval in milliseconds */\n  autoSyncInterval?: number;\n  /** Retry options for network operations */\n  retryOptions?: RetryOptions;\n  /** Maximum batch size for sync operations */\n  batchSize?: number;\n  /** Whether to include content in memory entries */\n  includeContent?: boolean;\n  /** Maximum content length to store */\n  maxContentLength?: number;\n}\n\n/**\n * Sync result for a single operation\n */\nexport interface SyncOperationResult {\n  success: boolean;\n  synced: number;\n  skipped: number;\n  failed: number;\n  conflicts: SyncConflict[];\n  errors: Array<{ nodeId: string; error: string }>;\n  duration: number;\n}\n\n/**\n * Full sync result\n */\nexport interface FullSyncResult {\n  success: boolean;\n  toMemory: SyncOperationResult;\n  fromMemory: SyncOperationResult;\n  totalDuration: number;\n  timestamp: Date;\n}\n\n/**\n * Vault Memory Sync\n *\n * Manages bidirectional synchronization between the knowledge graph vault\n * and claude-flow memory for cross-session persistence and agent coordination.\n *\n * @example\n * ```typescript\n * const sync = new VaultMemorySync({\n *   projectRoot: '/my/project',\n *   namespace: 'knowledge-graph',\n *   conflictStrategy: 'newest-wins',\n * });\n *\n * // Initialize with database\n * await sync.initialize(db);\n *\n * // Sync to memory\n * const result = await sync.syncToMemory();\n *\n * // Check status\n * const status = sync.getStatus();\n * ```\n */\nexport class VaultMemorySync {\n  private options: Required<VaultSyncOptions>;\n  private shadowCache: ShadowCache;\n  private db: KnowledgeGraphDatabase | null = null;\n  private memoryCache: Map<string, MemoryNode> = new Map();\n  private conflicts: SyncConflict[] = [];\n  private lastSyncTime: Date | null = null;\n  private isSyncing = false;\n  private syncErrors: string[] = [];\n  private autoSyncTimer: NodeJS.Timeout | null = null;\n\n  constructor(options: VaultSyncOptions) {\n    this.options = {\n      projectRoot: options.projectRoot,\n      namespace: options.namespace ?? 'knowledge-graph',\n      conflictStrategy: options.conflictStrategy ?? 'newest-wins',\n      autoSync: options.autoSync ?? false,\n      autoSyncInterval: options.autoSyncInterval ?? 300000, // 5 minutes\n      retryOptions: options.retryOptions ?? { maxRetries: 3, initialDelay: 1000 },\n      batchSize: options.batchSize ?? 50,\n      includeContent: options.includeContent ?? false,\n      maxContentLength: options.maxContentLength ?? 5000,\n    };\n\n    this.shadowCache = new ShadowCache({\n      projectRoot: options.projectRoot,\n      cacheDir: '.kg/sync-cache',\n    });\n  }\n\n  /**\n   * Initialize the sync system with database\n   */\n  async initialize(db: KnowledgeGraphDatabase): Promise<void> {\n    this.db = db;\n    await this.shadowCache.load();\n\n    // Load memory cache from previous sync\n    await this.loadMemoryCache();\n\n    if (this.options.autoSync) {\n      this.startAutoSync();\n    }\n\n    logger.info('Vault sync initialized', {\n      namespace: this.options.namespace,\n      autoSync: this.options.autoSync,\n    });\n  }\n\n  /**\n   * Sync knowledge graph to claude-flow memory\n   */\n  async syncToMemory(): Promise<SyncOperationResult> {\n    if (!this.db) {\n      throw new Error('Database not initialized. Call initialize() first.');\n    }\n\n    const startTime = Date.now();\n    const result: SyncOperationResult = {\n      success: true,\n      synced: 0,\n      skipped: 0,\n      failed: 0,\n      conflicts: [],\n      errors: [],\n      duration: 0,\n    };\n\n    this.isSyncing = true;\n    this.syncErrors = [];\n\n    try {\n      const nodes = this.db.getAllNodes();\n      const batches = this.createBatches(nodes, this.options.batchSize);\n\n      for (const batch of batches) {\n        for (const node of batch) {\n          try {\n            const memoryNode = this.nodeToMemoryEntry(node);\n            const cached = this.memoryCache.get(node.id);\n\n            // Check for conflicts\n            if (cached && cached.contentHash !== memoryNode.contentHash) {\n              const conflict = await this.detectConflict(node, cached);\n              if (conflict) {\n                result.conflicts.push(conflict);\n                const resolved = await this.resolveConflict(conflict);\n                if (!resolved) {\n                  result.skipped++;\n                  continue;\n                }\n              }\n            }\n\n            // Generate MCP command for sync\n            await this.storeToMemory(memoryNode);\n            this.memoryCache.set(node.id, memoryNode);\n            result.synced++;\n          } catch (error) {\n            result.failed++;\n            result.errors.push({\n              nodeId: node.id,\n              error: String(error),\n            });\n            this.syncErrors.push(`Failed to sync ${node.id}: ${error}`);\n          }\n        }\n      }\n\n      // Sync indexes and metadata\n      await this.syncIndexesToMemory(nodes);\n\n      result.duration = Date.now() - startTime;\n      result.success = result.failed === 0;\n      this.lastSyncTime = new Date();\n\n      logger.info('Sync to memory completed', {\n        synced: result.synced,\n        failed: result.failed,\n        duration: result.duration,\n      });\n    } finally {\n      this.isSyncing = false;\n      await this.saveMemoryCache();\n    }\n\n    return result;\n  }\n\n  /**\n   * Sync from claude-flow memory to knowledge graph\n   */\n  async syncFromMemory(): Promise<SyncOperationResult> {\n    if (!this.db) {\n      throw new Error('Database not initialized. Call initialize() first.');\n    }\n\n    const startTime = Date.now();\n    const result: SyncOperationResult = {\n      success: true,\n      synced: 0,\n      skipped: 0,\n      failed: 0,\n      conflicts: [],\n      errors: [],\n      duration: 0,\n    };\n\n    this.isSyncing = true;\n    this.syncErrors = [];\n\n    try {\n      // Retrieve node index from memory\n      const memoryNodes = await this.retrieveFromMemory();\n\n      for (const memoryNode of memoryNodes) {\n        try {\n          const existingNode = this.db.getNode(memoryNode.id);\n\n          if (existingNode) {\n            // Check for conflicts\n            const currentHash = this.computeContentHash(existingNode.content);\n            if (currentHash !== memoryNode.contentHash) {\n              const conflict = this.createConflictRecord(existingNode, memoryNode);\n              result.conflicts.push(conflict);\n\n              const resolved = await this.resolveConflict(conflict);\n              if (!resolved || conflict.resolvedAs === 'vault') {\n                result.skipped++;\n                continue;\n              }\n            }\n          }\n\n          // Memory sync would update vault files if needed\n          // For now, we track what would be synced\n          result.synced++;\n          this.memoryCache.set(memoryNode.id, memoryNode);\n        } catch (error) {\n          result.failed++;\n          result.errors.push({\n            nodeId: memoryNode.id,\n            error: String(error),\n          });\n        }\n      }\n\n      result.duration = Date.now() - startTime;\n      result.success = result.failed === 0;\n      this.lastSyncTime = new Date();\n\n      logger.info('Sync from memory completed', {\n        synced: result.synced,\n        failed: result.failed,\n        duration: result.duration,\n      });\n    } finally {\n      this.isSyncing = false;\n      await this.saveMemoryCache();\n    }\n\n    return result;\n  }\n\n  /**\n   * Perform full bidirectional sync\n   */\n  async fullSync(): Promise<FullSyncResult> {\n    const startTime = Date.now();\n\n    const toMemory = await this.syncToMemory();\n    const fromMemory = await this.syncFromMemory();\n\n    return {\n      success: toMemory.success && fromMemory.success,\n      toMemory,\n      fromMemory,\n      totalDuration: Date.now() - startTime,\n      timestamp: new Date(),\n    };\n  }\n\n  /**\n   * Get current sync status\n   */\n  getStatus(): SyncStatus {\n    const pendingVaultChanges = this.db\n      ? this.countPendingVaultChanges()\n      : 0;\n\n    const pendingMemoryChanges = this.countPendingMemoryChanges();\n\n    let health: SyncStatus['health'] = 'healthy';\n    if (this.syncErrors.length > 0) {\n      health = 'error';\n    } else if (this.conflicts.length > 0 || pendingVaultChanges > 10) {\n      health = 'warning';\n    }\n\n    return {\n      lastSync: this.lastSyncTime,\n      isSyncing: this.isSyncing,\n      pendingVaultChanges,\n      pendingMemoryChanges,\n      errors: [...this.syncErrors],\n      health,\n    };\n  }\n\n  /**\n   * Get unresolved conflicts\n   */\n  getConflicts(): SyncConflict[] {\n    return this.conflicts.filter(c => !c.resolvedAt);\n  }\n\n  /**\n   * Manually resolve a conflict\n   */\n  async resolveConflictManually(\n    nodeId: string,\n    resolution: 'vault' | 'memory'\n  ): Promise<boolean> {\n    const conflict = this.conflicts.find(\n      c => c.nodeId === nodeId && !c.resolvedAt\n    );\n\n    if (!conflict) {\n      return false;\n    }\n\n    conflict.resolvedAs = resolution;\n    conflict.resolvedAt = new Date();\n\n    if (resolution === 'vault' && this.db) {\n      // Re-sync vault version to memory\n      const node = this.db.getNode(nodeId);\n      if (node) {\n        const memoryNode = this.nodeToMemoryEntry(node);\n        await this.storeToMemory(memoryNode);\n        this.memoryCache.set(nodeId, memoryNode);\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Detect changes in vault since last sync\n   */\n  async detectChanges(): Promise<FileChange[]> {\n    if (!this.db) {\n      return [];\n    }\n\n    const nodes = this.db.getAllNodes();\n    const filePaths = nodes.map(n => n.path);\n\n    return this.shadowCache.detectChanges(filePaths);\n  }\n\n  /**\n   * Stop the sync system\n   */\n  stop(): void {\n    if (this.autoSyncTimer) {\n      clearInterval(this.autoSyncTimer);\n      this.autoSyncTimer = null;\n    }\n    this.saveMemoryCache().catch(err =>\n      logger.error('Failed to save memory cache on stop', err)\n    );\n  }\n\n  // Private methods\n\n  private startAutoSync(): void {\n    if (this.autoSyncTimer) {\n      clearInterval(this.autoSyncTimer);\n    }\n\n    this.autoSyncTimer = setInterval(async () => {\n      if (!this.isSyncing) {\n        try {\n          await this.syncToMemory();\n        } catch (error) {\n          logger.error('Auto-sync failed', error as Error);\n        }\n      }\n    }, this.options.autoSyncInterval);\n  }\n\n  private nodeToMemoryEntry(node: KnowledgeNode): MemoryNode {\n    const summary = this.extractSummary(node.content);\n    const contentHash = this.computeContentHash(node.content);\n\n    return {\n      id: node.id,\n      title: node.title,\n      type: node.type,\n      status: node.status,\n      path: node.path,\n      tags: node.tags,\n      outgoingLinks: node.outgoingLinks.map(l => l.target),\n      incomingLinks: node.incomingLinks.map(l => l.target),\n      summary,\n      contentHash,\n      lastModified: node.lastModified.toISOString(),\n      syncedAt: new Date().toISOString(),\n    };\n  }\n\n  private extractSummary(content: string, maxLength = 200): string {\n    const lines = content.split('\\n');\n    let summary = '';\n\n    for (const line of lines) {\n      const trimmed = line.trim();\n      if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('```') || trimmed === '---') {\n        continue;\n      }\n      summary = trimmed;\n      break;\n    }\n\n    if (summary.length > maxLength) {\n      summary = summary.slice(0, maxLength - 3) + '...';\n    }\n\n    return summary;\n  }\n\n  private computeContentHash(content: string): string {\n    return createHash('md5').update(content).digest('hex').substring(0, 16);\n  }\n\n  private async storeToMemory(node: MemoryNode): Promise<void> {\n    // This would integrate with actual claude-flow MCP calls\n    // For now, we log the command that would be executed\n    logger.debug('Store to memory', {\n      key: `node/${node.id}`,\n      namespace: this.options.namespace,\n    });\n\n    // In production, this would call:\n    // await mcpClient.memoryUsage({\n    //   action: 'store',\n    //   key: `node/${node.id}`,\n    //   namespace: this.options.namespace,\n    //   value: JSON.stringify(node),\n    // });\n  }\n\n  private async retrieveFromMemory(): Promise<MemoryNode[]> {\n    // This would integrate with actual claude-flow MCP calls\n    // For now, return cached nodes\n    logger.debug('Retrieve from memory', {\n      namespace: this.options.namespace,\n    });\n\n    return Array.from(this.memoryCache.values());\n  }\n\n  private async syncIndexesToMemory(nodes: KnowledgeNode[]): Promise<void> {\n    // Sync node index\n    const nodeIndex = nodes.map(n => ({\n      id: n.id,\n      title: n.title,\n      type: n.type,\n      path: n.path,\n    }));\n\n    logger.debug('Sync node index', {\n      count: nodeIndex.length,\n      namespace: this.options.namespace,\n    });\n\n    // Sync tag index\n    const tagIndex: Record<string, string[]> = {};\n    for (const node of nodes) {\n      for (const tag of node.tags) {\n        if (!tagIndex[tag]) {\n          tagIndex[tag] = [];\n        }\n        tagIndex[tag].push(node.id);\n      }\n    }\n\n    logger.debug('Sync tag index', {\n      tags: Object.keys(tagIndex).length,\n      namespace: this.options.namespace,\n    });\n\n    // Sync metadata\n    const metadata = {\n      lastSync: new Date().toISOString(),\n      nodeCount: nodes.length,\n      namespace: this.options.namespace,\n    };\n\n    logger.debug('Sync metadata', metadata);\n  }\n\n  private async detectConflict(\n    node: KnowledgeNode,\n    cached: MemoryNode\n  ): Promise<SyncConflict | null> {\n    const vaultHash = this.computeContentHash(node.content);\n\n    if (vaultHash === cached.contentHash) {\n      return null; // No conflict\n    }\n\n    return {\n      nodeId: node.id,\n      path: node.path,\n      vaultVersion: {\n        hash: vaultHash,\n        modifiedAt: node.lastModified,\n        content: this.options.includeContent ? node.content : undefined,\n      },\n      memoryVersion: {\n        hash: cached.contentHash,\n        modifiedAt: new Date(cached.lastModified),\n      },\n    };\n  }\n\n  private createConflictRecord(\n    node: KnowledgeNode,\n    memoryNode: MemoryNode\n  ): SyncConflict {\n    return {\n      nodeId: node.id,\n      path: node.path,\n      vaultVersion: {\n        hash: this.computeContentHash(node.content),\n        modifiedAt: node.lastModified,\n      },\n      memoryVersion: {\n        hash: memoryNode.contentHash,\n        modifiedAt: new Date(memoryNode.lastModified),\n      },\n    };\n  }\n\n  private async resolveConflict(conflict: SyncConflict): Promise<boolean> {\n    switch (this.options.conflictStrategy) {\n      case 'vault-wins':\n        conflict.resolvedAs = 'vault';\n        conflict.resolvedAt = new Date();\n        return true;\n\n      case 'memory-wins':\n        conflict.resolvedAs = 'memory';\n        conflict.resolvedAt = new Date();\n        return true;\n\n      case 'newest-wins':\n        if (conflict.vaultVersion.modifiedAt > conflict.memoryVersion.modifiedAt) {\n          conflict.resolvedAs = 'vault';\n        } else {\n          conflict.resolvedAs = 'memory';\n        }\n        conflict.resolvedAt = new Date();\n        return true;\n\n      case 'merge':\n        // Merge strategy would require content comparison\n        // For now, fall back to newest-wins\n        if (conflict.vaultVersion.modifiedAt > conflict.memoryVersion.modifiedAt) {\n          conflict.resolvedAs = 'vault';\n        } else {\n          conflict.resolvedAs = 'memory';\n        }\n        conflict.resolvedAt = new Date();\n        return true;\n\n      case 'manual':\n        // Don't auto-resolve, add to conflicts list\n        this.conflicts.push(conflict);\n        return false;\n\n      default:\n        return false;\n    }\n  }\n\n  private countPendingVaultChanges(): number {\n    const cachedHashes = new Map<string, string>();\n    for (const [id, node] of this.memoryCache) {\n      cachedHashes.set(id, node.contentHash);\n    }\n\n    let pending = 0;\n    const nodes = this.db?.getAllNodes() ?? [];\n\n    for (const node of nodes) {\n      const cachedHash = cachedHashes.get(node.id);\n      const currentHash = this.computeContentHash(node.content);\n\n      if (!cachedHash || cachedHash !== currentHash) {\n        pending++;\n      }\n    }\n\n    return pending;\n  }\n\n  private countPendingMemoryChanges(): number {\n    // In a real implementation, this would check memory for changes\n    // that haven't been synced to vault\n    return 0;\n  }\n\n  private createBatches<T>(items: T[], batchSize: number): T[][] {\n    const batches: T[][] = [];\n    for (let i = 0; i < items.length; i += batchSize) {\n      batches.push(items.slice(i, i + batchSize));\n    }\n    return batches;\n  }\n\n  private async loadMemoryCache(): Promise<void> {\n    // In production, this would load from persistent storage\n    // or retrieve the current state from claude-flow memory\n    logger.debug('Loading memory cache');\n  }\n\n  private async saveMemoryCache(): Promise<void> {\n    // Persist cache to disk for recovery\n    await this.shadowCache.save();\n    logger.debug('Memory cache saved');\n  }\n}\n\n/**\n * Create a vault memory sync instance\n */\nexport function createVaultMemorySync(options: VaultSyncOptions): VaultMemorySync {\n  return new VaultMemorySync(options);\n}\n"],"names":[],"mappings":"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"}