agentdb 1.0.0

package/dist/sync/delta.mjs

@@ -0,0 +1,238 @@
+/**
+ * SQLiteVector QUIC Sync - Delta Computation
+ *
+ * Efficient delta computation from SQLite changelog for sync
+ */
+import { createHash } from 'crypto';
+import { pack, unpack } from 'msgpackr';
+/**
+ * Delta encoder for vector changes
+ */
+export class DeltaEncoder {
+    /**
+     * Encode changes into compressed delta package
+     */
+    static encode(shardId, changes, compression = 'msgpack') {
+        if (changes.length === 0) {
+            throw new Error('Cannot encode empty changes');
+        }
+        const fromChangeId = Math.min(...changes.map(c => c.id));
+        const toChangeId = Math.max(...changes.map(c => c.id));
+        // Serialize changes based on compression
+        let processedChanges = changes;
+        if (compression === 'msgpack') {
+            // MessagePack handles compression automatically
+            processedChanges = changes.map(c => ({
+                ...c,
+                // Convert Map to Object for serialization
+                versionVector: Object.fromEntries(c.versionVector),
+                // Convert Float32Array to regular array for msgpack
+                vector: c.vector ? Array.from(c.vector) : undefined
+            }));
+        }
+        // Calculate checksum
+        const checksum = this.calculateChecksum(changes);
+        return {
+            shardId,
+            fromChangeId,
+            toChangeId,
+            changes: processedChanges,
+            checksum,
+            compression
+        };
+    }
+    /**
+     * Decode delta package back to changes
+     */
+    static decode(delta) {
+        // Verify checksum
+        const calculatedChecksum = this.calculateChecksum(delta.changes);
+        if (calculatedChecksum !== delta.checksum) {
+            throw new Error('Delta checksum mismatch - data corruption detected');
+        }
+        // Deserialize based on compression
+        if (delta.compression === 'msgpack') {
+            return delta.changes.map(c => ({
+                ...c,
+                // Convert Object back to Map
+                versionVector: new Map(Object.entries(c.versionVector)),
+                // Convert array back to Float32Array
+                vector: c.vector ? new Float32Array(c.vector) : undefined
+            }));
+        }
+        return delta.changes;
+    }
+    /**
+     * Serialize delta to bytes for QUIC transmission
+     */
+    static serialize(delta) {
+        const packed = pack(delta);
+        return packed;
+    }
+    /**
+     * Deserialize bytes back to delta
+     */
+    static deserialize(bytes) {
+        const delta = unpack(bytes);
+        // Reconstruct Maps and typed arrays
+        delta.changes = delta.changes.map(c => ({
+            ...c,
+            versionVector: new Map(Object.entries(c.versionVector || {})),
+            vector: c.vector ? new Float32Array(c.vector) : undefined
+        }));
+        return delta;
+    }
+    /**
+     * Calculate checksum for changes
+     */
+    static calculateChecksum(changes) {
+        const hash = createHash('sha256');
+        // Sort by ID for deterministic hash
+        const sorted = [...changes].sort((a, b) => a.id - b.id);
+        for (const change of sorted) {
+            hash.update(change.id.toString());
+            hash.update(change.operation);
+            hash.update(change.vectorId);
+            hash.update(change.timestamp.toString());
+        }
+        return hash.digest('hex');
+    }
+    /**
+     * Split large change sets into batches
+     */
+    static batch(changes, batchSize) {
+        const batches = [];
+        for (let i = 0; i < changes.length; i += batchSize) {
+            batches.push(changes.slice(i, i + batchSize));
+        }
+        return batches;
+    }
+    /**
+     * Optimize delta by removing redundant operations
+     */
+    static optimize(changes) {
+        const latestByVector = new Map();
+        // Keep only latest change per vector
+        for (const change of changes) {
+            const existing = latestByVector.get(change.vectorId);
+            if (!existing || change.timestamp > existing.timestamp) {
+                latestByVector.set(change.vectorId, change);
+            }
+        }
+        return Array.from(latestByVector.values()).sort((a, b) => a.id - b.id);
+    }
+}
+/**
+ * SQLite changelog reader
+ */
+export class ChangelogReader {
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Read changes from SQLite changelog
+     */
+    async readChanges(shardId, fromChangeId, toChangeId) {
+        const changes = [];
+        // Query changelog table
+        const query = toChangeId
+            ? `SELECT * FROM vector_changelog
+         WHERE shard_id = ? AND change_id > ? AND change_id <= ?
+         ORDER BY change_id ASC`
+            : `SELECT * FROM vector_changelog
+         WHERE shard_id = ? AND change_id > ?
+         ORDER BY change_id ASC`;
+        const params = toChangeId
+            ? [shardId, fromChangeId, toChangeId]
+            : [shardId, fromChangeId];
+        const rows = this.db.prepare(query).all(...params);
+        for (const row of rows) {
+            changes.push({
+                id: row.change_id,
+                operation: row.operation,
+                shardId: row.shard_id,
+                vectorId: row.vector_id,
+                vector: row.vector_data ? new Float32Array(JSON.parse(row.vector_data)) : undefined,
+                metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+                timestamp: row.timestamp,
+                sourceNode: row.source_node,
+                versionVector: new Map(JSON.parse(row.version_vector || '{}'))
+            });
+        }
+        return changes;
+    }
+    /**
+     * Get latest change ID for shard
+     */
+    async getLatestChangeId(shardId) {
+        const row = this.db.prepare(`SELECT MAX(change_id) as max_id FROM vector_changelog WHERE shard_id = ?`).get(shardId);
+        return row?.max_id || 0;
+    }
+    /**
+     * Get version vector for shard
+     */
+    async getVersionVector(shardId) {
+        const row = this.db.prepare(`SELECT version_vector FROM shard_metadata WHERE shard_id = ?`).get(shardId);
+        if (!row) {
+            return new Map();
+        }
+        return new Map(Object.entries(JSON.parse(row.version_vector)));
+    }
+    /**
+     * Update version vector after sync
+     */
+    async updateVersionVector(shardId, versionVector) {
+        const vvJson = JSON.stringify(Object.fromEntries(versionVector));
+        this.db.prepare(`INSERT OR REPLACE INTO shard_metadata (shard_id, version_vector, updated_at)
+       VALUES (?, ?, ?)`).run(shardId, vvJson, Date.now());
+    }
+}
+/**
+ * Version vector utilities for causal ordering
+ */
+export class VersionVector {
+    /**
+     * Compare two version vectors
+     * Returns: -1 (a < b), 0 (concurrent), 1 (a > b)
+     */
+    static compare(a, b) {
+        let aGreater = false;
+        let bGreater = false;
+        // Get all node IDs
+        const allNodes = new Set([...a.keys(), ...b.keys()]);
+        for (const nodeId of allNodes) {
+            const aVersion = a.get(nodeId) || 0;
+            const bVersion = b.get(nodeId) || 0;
+            if (aVersion > bVersion) {
+                aGreater = true;
+            }
+            else if (bVersion > aVersion) {
+                bGreater = true;
+            }
+        }
+        if (aGreater && !bGreater)
+            return 1;
+        if (bGreater && !aGreater)
+            return -1;
+        return 0; // Concurrent
+    }
+    /**
+     * Merge two version vectors (element-wise max)
+     */
+    static merge(a, b) {
+        const merged = new Map(a);
+        for (const [nodeId, version] of b) {
+            const currentVersion = merged.get(nodeId) || 0;
+            merged.set(nodeId, Math.max(currentVersion, version));
+        }
+        return merged;
+    }
+    /**
+     * Increment version for node
+     */
+    static increment(vv, nodeId) {
+        const updated = new Map(vv);
+        updated.set(nodeId, (updated.get(nodeId) || 0) + 1);
+        return updated;
+    }
+}

package/dist/sync/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * SQLiteVector QUIC Sync - Main Export
+ *
+ * Real-time vector database synchronization using QUIC
+ */
+export { VectorQuicSync, createVectorSync } from './quic-sync';
+export { ShardCoordinator, createShardCoordinator, type PeerInfo } from './coordinator';
+export { DeltaEncoder, ChangelogReader, VersionVector } from './delta';
+export { ConflictResolver, ConflictTracker } from './conflict';
+export type { VectorChange, VectorDelta, ChangeOperation, ConflictStrategy, SyncConflict, SyncResult, SyncSession, SyncConfig, ShardState, CoordinatorStats } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/sync/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sync/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,cAAc,EACd,gBAAgB,EACjB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,KAAK,QAAQ,EACd,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,YAAY,EACZ,eAAe,EACf,aAAa,EACd,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,gBAAgB,EAChB,eAAe,EAChB,MAAM,YAAY,CAAC;AAEpB,YAAY,EACV,YAAY,EACZ,WAAW,EACX,eAAe,EACf,gBAAgB,EAChB,YAAY,EACZ,UAAU,EACV,WAAW,EACX,UAAU,EACV,UAAU,EACV,gBAAgB,EACjB,MAAM,SAAS,CAAC"}

package/dist/sync/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * SQLiteVector QUIC Sync - Main Export
+ *
+ * Real-time vector database synchronization using QUIC
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConflictTracker = exports.ConflictResolver = exports.VersionVector = exports.ChangelogReader = exports.DeltaEncoder = exports.createShardCoordinator = exports.ShardCoordinator = exports.createVectorSync = exports.VectorQuicSync = void 0;
+var quic_sync_1 = require("./quic-sync");
+Object.defineProperty(exports, "VectorQuicSync", { enumerable: true, get: function () { return quic_sync_1.VectorQuicSync; } });
+Object.defineProperty(exports, "createVectorSync", { enumerable: true, get: function () { return quic_sync_1.createVectorSync; } });
+var coordinator_1 = require("./coordinator");
+Object.defineProperty(exports, "ShardCoordinator", { enumerable: true, get: function () { return coordinator_1.ShardCoordinator; } });
+Object.defineProperty(exports, "createShardCoordinator", { enumerable: true, get: function () { return coordinator_1.createShardCoordinator; } });
+var delta_1 = require("./delta");
+Object.defineProperty(exports, "DeltaEncoder", { enumerable: true, get: function () { return delta_1.DeltaEncoder; } });
+Object.defineProperty(exports, "ChangelogReader", { enumerable: true, get: function () { return delta_1.ChangelogReader; } });
+Object.defineProperty(exports, "VersionVector", { enumerable: true, get: function () { return delta_1.VersionVector; } });
+var conflict_1 = require("./conflict");
+Object.defineProperty(exports, "ConflictResolver", { enumerable: true, get: function () { return conflict_1.ConflictResolver; } });
+Object.defineProperty(exports, "ConflictTracker", { enumerable: true, get: function () { return conflict_1.ConflictTracker; } });
+//# sourceMappingURL=index.js.map

package/dist/sync/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/sync/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,yCAGqB;AAFnB,2GAAA,cAAc,OAAA;AACd,6GAAA,gBAAgB,OAAA;AAGlB,6CAIuB;AAHrB,+GAAA,gBAAgB,OAAA;AAChB,qHAAA,sBAAsB,OAAA;AAIxB,iCAIiB;AAHf,qGAAA,YAAY,OAAA;AACZ,wGAAA,eAAe,OAAA;AACf,sGAAA,aAAa,OAAA;AAGf,uCAGoB;AAFlB,4GAAA,gBAAgB,OAAA;AAChB,2GAAA,eAAe,OAAA"}

package/dist/sync/index.mjs

@@ -0,0 +1,9 @@
+/**
+ * SQLiteVector QUIC Sync - Main Export
+ *
+ * Real-time vector database synchronization using QUIC
+ */
+export { VectorQuicSync, createVectorSync } from './quic-sync.mjs';
+export { ShardCoordinator, createShardCoordinator } from './coordinator.mjs';
+export { DeltaEncoder, ChangelogReader, VersionVector } from './delta.mjs';
+export { ConflictResolver, ConflictTracker } from './conflict.mjs';

package/dist/sync/quic-sync.d.ts

@@ -0,0 +1,81 @@
+/**
+ * SQLiteVector QUIC Sync - Main Synchronization Layer
+ *
+ * Real-time shard synchronization using QUIC transport from agentic-flow
+ */
+import type { SyncResult, SyncSession, SyncConfig, ShardState } from './types';
+/**
+ * QUIC-based vector database synchronization
+ */
+export declare class VectorQuicSync {
+    private transport;
+    private changelogReader;
+    private conflictResolver;
+    private conflictTracker;
+    private config;
+    private nodeId;
+    private session;
+    private syncTimers;
+    constructor(db: any, nodeId: string, config?: Partial<SyncConfig>);
+    /**
+     * Initialize QUIC transport and sync session
+     */
+    initialize(quicConfig?: any): Promise<void>;
+    /**
+     * Synchronize shard with remote peer
+     */
+    sync(shardId: string, peerAddress: string, force?: boolean): Promise<SyncResult>;
+    /**
+     * Request remote changes from peer
+     */
+    private requestRemoteChanges;
+    /**
+     * Send local changes to peer
+     */
+    private sendLocalChanges;
+    /**
+     * Apply changes to local database
+     */
+    private applyChanges;
+    /**
+     * Start automatic periodic sync
+     */
+    startAutoSync(shardId: string, peerAddress: string): void;
+    /**
+     * Stop automatic sync for shard
+     */
+    stopAutoSync(shardId: string): void;
+    /**
+     * Stop all automatic syncs
+     */
+    stopAllAutoSyncs(): void;
+    /**
+     * Get current session
+     */
+    getSession(): SyncSession | null;
+    /**
+     * Get shard state
+     */
+    getShardState(shardId: string): Promise<ShardState>;
+    /**
+     * Get unresolved conflicts
+     */
+    getUnresolvedConflicts(shardId?: string): any[];
+    /**
+     * Save session to persistent storage
+     */
+    private saveSession;
+    /**
+     * Restore session from persistent storage
+     */
+    private restoreSession;
+    /**
+     * Close sync and cleanup resources
+     */
+    close(): Promise<void>;
+}
+/**
+ * Create VectorQuicSync instance with convenience wrapper
+ */
+export declare function createVectorSync(db: any, nodeId: string, config?: Partial<SyncConfig>, quicConfig?: any): Promise<VectorQuicSync>;
+//# sourceMappingURL=quic-sync.d.ts.map

package/dist/sync/quic-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quic-sync.d.ts","sourceRoot":"","sources":["../../src/sync/quic-sync.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAkDH,OAAO,KAAK,EAGV,UAAU,EACV,WAAW,EACX,UAAU,EACV,UAAU,EACX,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAA4B;IAC3C,OAAO,CAAC,UAAU,CAA0C;gBAG1D,EAAE,EAAE,GAAG,EACP,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,OAAO,CAAC,UAAU,CAAM;IAoBlC;;OAEG;IACG,UAAU,CAAC,UAAU,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IA4BjD;;OAEG;IACG,IAAI,CACR,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,KAAK,GAAE,OAAe,GACrB,OAAO,CAAC,UAAU,CAAC;IA2FtB;;OAEG;YACW,oBAAoB;IA2BlC;;OAEG;YACW,gBAAgB;IA+B9B;;OAEG;YACW,YAAY;IA8B1B;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IAgBzD;;OAEG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAQnC;;OAEG;IACH,gBAAgB,IAAI,IAAI;IAMxB;;OAEG;IACH,UAAU,IAAI,WAAW,GAAG,IAAI;IAIhC;;OAEG;IACG,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAezD;;OAEG;IACH,sBAAsB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,GAAG,EAAE;IAM/C;;OAEG;YACW,WAAW;IAmBzB;;OAEG;YACW,cAAc;IAK5B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAS7B;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,GAAG,EACP,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,EAC5B,UAAU,CAAC,EAAE,GAAG,GACf,OAAO,CAAC,cAAc,CAAC,CAIzB"}