@weavelogic/knowledge-graph-agent 0.2.0 → 0.3.0

package/dist/memory/vault-sync.d.ts

@@ -0,0 +1,212 @@
+/**
+ * Vault Memory Sync
+ *
+ * Provides bidirectional synchronization between the knowledge graph
+ * and claude-flow memory system for persistent agent coordination.
+ *
+ * @module memory/vault-sync
+ */
+import { type RetryOptions } from '../utils/index.js';
+import { type FileChange } from '../core/cache.js';
+import { KnowledgeGraphDatabase } from '../core/database.js';
+/**
+ * Sync direction
+ */
+export type SyncDirection = 'to-memory' | 'from-memory' | 'bidirectional';
+/**
+ * Conflict resolution strategy
+ */
+export type ConflictStrategy = 'memory-wins' | 'vault-wins' | 'newest-wins' | 'merge' | 'manual';
+/**
+ * Sync status
+ */
+export interface SyncStatus {
+    /** Last successful sync timestamp */
+    lastSync: Date | null;
+    /** Whether sync is currently running */
+    isSyncing: boolean;
+    /** Number of pending changes in vault */
+    pendingVaultChanges: number;
+    /** Number of pending changes in memory */
+    pendingMemoryChanges: number;
+    /** Any sync errors */
+    errors: string[];
+    /** Sync health status */
+    health: 'healthy' | 'warning' | 'error';
+}
+/**
+ * Memory entry format for claude-flow
+ */
+export interface MemoryNode {
+    id: string;
+    title: string;
+    type: string;
+    status: string;
+    path: string;
+    tags: string[];
+    outgoingLinks: string[];
+    incomingLinks: string[];
+    summary: string;
+    contentHash: string;
+    lastModified: string;
+    syncedAt: string;
+}
+/**
+ * Conflict record
+ */
+export interface SyncConflict {
+    nodeId: string;
+    path: string;
+    vaultVersion: {
+        hash: string;
+        modifiedAt: Date;
+        content?: string;
+    };
+    memoryVersion: {
+        hash: string;
+        modifiedAt: Date;
+        content?: string;
+    };
+    resolvedAs?: 'vault' | 'memory' | 'merged';
+    resolvedAt?: Date;
+}
+/**
+ * Sync options
+ */
+export interface VaultSyncOptions {
+    /** Project root directory */
+    projectRoot: string;
+    /** Claude-flow memory namespace */
+    namespace?: string;
+    /** Conflict resolution strategy */
+    conflictStrategy?: ConflictStrategy;
+    /** Whether to auto-sync on changes */
+    autoSync?: boolean;
+    /** Auto-sync interval in milliseconds */
+    autoSyncInterval?: number;
+    /** Retry options for network operations */
+    retryOptions?: RetryOptions;
+    /** Maximum batch size for sync operations */
+    batchSize?: number;
+    /** Whether to include content in memory entries */
+    includeContent?: boolean;
+    /** Maximum content length to store */
+    maxContentLength?: number;
+}
+/**
+ * Sync result for a single operation
+ */
+export interface SyncOperationResult {
+    success: boolean;
+    synced: number;
+    skipped: number;
+    failed: number;
+    conflicts: SyncConflict[];
+    errors: Array<{
+        nodeId: string;
+        error: string;
+    }>;
+    duration: number;
+}
+/**
+ * Full sync result
+ */
+export interface FullSyncResult {
+    success: boolean;
+    toMemory: SyncOperationResult;
+    fromMemory: SyncOperationResult;
+    totalDuration: number;
+    timestamp: Date;
+}
+/**
+ * Vault Memory Sync
+ *
+ * Manages bidirectional synchronization between the knowledge graph vault
+ * and claude-flow memory for cross-session persistence and agent coordination.
+ *
+ * @example
+ * ```typescript
+ * const sync = new VaultMemorySync({
+ *   projectRoot: '/my/project',
+ *   namespace: 'knowledge-graph',
+ *   conflictStrategy: 'newest-wins',
+ * });
+ *
+ * // Initialize with database
+ * await sync.initialize(db);
+ *
+ * // Sync to memory
+ * const result = await sync.syncToMemory();
+ *
+ * // Check status
+ * const status = sync.getStatus();
+ * ```
+ */
+export declare class VaultMemorySync {
+    private options;
+    private shadowCache;
+    private db;
+    private memoryCache;
+    private conflicts;
+    private lastSyncTime;
+    private isSyncing;
+    private syncErrors;
+    private autoSyncTimer;
+    constructor(options: VaultSyncOptions);
+    /**
+     * Initialize the sync system with database
+     */
+    initialize(db: KnowledgeGraphDatabase): Promise<void>;
+    /**
+     * Sync knowledge graph to claude-flow memory
+     */
+    syncToMemory(): Promise<SyncOperationResult>;
+    /**
+     * Sync from claude-flow memory to knowledge graph
+     */
+    syncFromMemory(): Promise<SyncOperationResult>;
+    /**
+     * Perform full bidirectional sync
+     */
+    fullSync(): Promise<FullSyncResult>;
+    /**
+     * Get current sync status
+     */
+    getStatus(): SyncStatus;
+    /**
+     * Get unresolved conflicts
+     */
+    getConflicts(): SyncConflict[];
+    /**
+     * Manually resolve a conflict
+     */
+    resolveConflictManually(nodeId: string, resolution: 'vault' | 'memory'): Promise<boolean>;
+    /**
+     * Detect changes in vault since last sync
+     */
+    detectChanges(): Promise<FileChange[]>;
+    /**
+     * Stop the sync system
+     */
+    stop(): void;
+    private startAutoSync;
+    private nodeToMemoryEntry;
+    private extractSummary;
+    private computeContentHash;
+    private storeToMemory;
+    private retrieveFromMemory;
+    private syncIndexesToMemory;
+    private detectConflict;
+    private createConflictRecord;
+    private resolveConflict;
+    private countPendingVaultChanges;
+    private countPendingMemoryChanges;
+    private createBatches;
+    private loadMemoryCache;
+    private saveMemoryCache;
+}
+/**
+ * Create a vault memory sync instance
+ */
+export declare function createVaultMemorySync(options: VaultSyncOptions): VaultMemorySync;
+//# sourceMappingURL=vault-sync.d.ts.map

package/dist/memory/vault-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vault-sync.d.ts","sourceRoot":"","sources":["../../src/memory/vault-sync.ts"],"names":[],"mappings":"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"}

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