@ninebix/nmt-system 1.0.0

package/dist/storage/redis-store.d.ts

@@ -0,0 +1,174 @@
+/**
+ * Redis-based Storage for NMT System
+ * Replaces all LevelDB stores with Redis
+ *
+ * @module storage/redis-store
+ */
+import type { UUID, SHA3Hash, Chunk, NeuronNode, Synapse, SynapseType, Embedding384 } from '../types/index.js';
+/**
+ * Redis Store Options
+ */
+export interface RedisStoreOptions {
+    host?: string;
+    port?: number;
+    password?: string;
+    db?: number;
+    keyPrefix?: string;
+    dataDir?: string;
+}
+/**
+ * Unified Redis Store
+ */
+export declare class RedisStore {
+    private redis;
+    private keyPrefix;
+    private dataDir;
+    private chunkDir;
+    private initialized;
+    constructor(options?: RedisStoreOptions);
+    /**
+     * Initialize store
+     */
+    init(): Promise<void>;
+    /**
+     * Close store
+     */
+    close(): Promise<void>;
+    /**
+     * Store a chunk
+     */
+    putChunk(chunk: Chunk): Promise<SHA3Hash>;
+    /**
+     * Store multiple chunks
+     */
+    putChunks(chunks: Chunk[]): Promise<SHA3Hash[]>;
+    /**
+     * Get a chunk
+     */
+    getChunk(chunkHash: SHA3Hash): Promise<Chunk | null>;
+    /**
+     * Get multiple chunks
+     */
+    getChunks(hashes: SHA3Hash[]): Promise<(Chunk | null)[]>;
+    /**
+     * Check if chunk exists
+     */
+    hasChunk(chunkHash: SHA3Hash): Promise<boolean>;
+    /**
+     * Delete a chunk
+     */
+    deleteChunk(chunkHash: SHA3Hash): Promise<boolean>;
+    /**
+     * Get all chunk hashes
+     */
+    getAllChunkHashes(): Promise<SHA3Hash[]>;
+    /**
+     * Get chunk stats
+     */
+    getChunkStats(): Promise<{
+        totalChunks: number;
+        totalSize: number;
+        avgChunkSize: number;
+    }>;
+    /**
+     * Create a new neuron
+     */
+    createNeuron(input: {
+        embedding: Embedding384;
+        chunkHashes: string[];
+        merkleRoot: string;
+        sourceType?: string;
+        tags?: string[];
+    }): Promise<NeuronNode>;
+    /**
+     * Store a neuron
+     */
+    putNeuron(neuron: NeuronNode): Promise<void>;
+    /**
+     * Get a neuron by ID
+     */
+    getNeuron(id: UUID): Promise<NeuronNode | null>;
+    /**
+     * Get neuron by Merkle root
+     */
+    getNeuronByMerkleRoot(merkleRoot: string): Promise<NeuronNode | null>;
+    /**
+     * Update a neuron
+     */
+    updateNeuron(id: UUID, updates: Partial<NeuronNode>): Promise<NeuronNode | null>;
+    /**
+     * Delete a neuron
+     */
+    deleteNeuron(id: UUID): Promise<boolean>;
+    /**
+     * Record neuron access
+     */
+    recordNeuronAccess(id: UUID): Promise<void>;
+    /**
+     * Get all neuron IDs
+     */
+    getAllNeuronIds(): Promise<UUID[]>;
+    /**
+     * Get neurons by tag
+     */
+    getNeuronsByTag(tag: string): Promise<NeuronNode[]>;
+    /**
+     * Get neuron count
+     */
+    getNeuronCount(): Promise<number>;
+    /**
+     * Create a synapse
+     */
+    createSynapse(sourceId: UUID, targetId: UUID, type: SynapseType, weight?: number, bidirectional?: boolean): Promise<Synapse | null>;
+    /**
+     * Store a synapse
+     */
+    putSynapse(synapse: Synapse): Promise<void>;
+    /**
+     * Get a synapse
+     */
+    getSynapse(id: UUID): Promise<Synapse | null>;
+    /**
+     * Get outgoing synapses
+     */
+    getOutgoingSynapses(neuronId: UUID): Promise<Synapse[]>;
+    /**
+     * Get incoming synapses
+     */
+    getIncomingSynapses(neuronId: UUID): Promise<Synapse[]>;
+    /**
+     * Update synapse weight
+     */
+    updateSynapseWeight(id: UUID, weight: number): Promise<Synapse | null>;
+    /**
+     * Delete a synapse
+     */
+    deleteSynapse(id: UUID): Promise<boolean>;
+    /**
+     * Get synapse count
+     */
+    getSynapseCount(): Promise<number>;
+    /**
+     * Save HNSW index
+     */
+    saveIndex(name: string, indexData: any): Promise<void>;
+    /**
+     * Load HNSW index
+     */
+    loadIndex(name: string): Promise<any | null>;
+    private getChunkPath;
+    private ensureInitialized;
+    /**
+     * Get overall stats
+     */
+    getStats(): Promise<{
+        chunks: {
+            total: number;
+            size: number;
+        };
+        neurons: number;
+        synapses: number;
+    }>;
+}
+export declare function createRedisStore(options?: RedisStoreOptions): RedisStore;
+//# sourceMappingURL=redis-store.d.ts.map

package/dist/storage/redis-store.d.ts.map

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

package/dist/storage/redis-store.js

@@ -0,0 +1,506 @@
+/**
+ * Redis-based Storage for NMT System
+ * Replaces all LevelDB stores with Redis
+ *
+ * @module storage/redis-store
+ */
+import Redis from 'ioredis';
+import { generateUUID } from '../utils/uuid.js';
+import { verifyHash } from '../utils/hash.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+/**
+ * Unified Redis Store
+ */
+export class RedisStore {
+    redis;
+    keyPrefix;
+    dataDir;
+    chunkDir;
+    initialized = false;
+    constructor(options = {}) {
+        this.keyPrefix = options.keyPrefix || 'nmt:';
+        this.dataDir = options.dataDir || './data';
+        this.chunkDir = path.join(this.dataDir, 'chunks');
+        this.redis = new Redis({
+            host: options.host || 'localhost',
+            port: options.port || 6379,
+            password: options.password,
+            db: options.db || 0,
+            keyPrefix: this.keyPrefix,
+            retryStrategy: (times) => Math.min(times * 100, 3000),
+            lazyConnect: true,
+        });
+    }
+    /**
+     * Initialize store
+     */
+    async init() {
+        if (this.initialized)
+            return;
+        await this.redis.connect();
+        console.log('Redis Store connected');
+        // Ensure chunk directory exists
+        await fs.mkdir(this.chunkDir, { recursive: true });
+        this.initialized = true;
+    }
+    /**
+     * Close store
+     */
+    async close() {
+        if (!this.initialized)
+            return;
+        await this.redis.quit();
+        this.initialized = false;
+    }
+    // ==================== Chunk Operations ====================
+    /**
+     * Store a chunk
+     */
+    async putChunk(chunk) {
+        this.ensureInitialized();
+        const chunkHash = chunk.hash;
+        // Check if exists
+        const existing = await this.redis.hget('chunks:meta', chunkHash);
+        if (existing) {
+            const meta = JSON.parse(existing);
+            meta.refCount++;
+            await this.redis.hset('chunks:meta', chunkHash, JSON.stringify(meta));
+            return chunkHash;
+        }
+        // Store chunk data to file
+        const chunkPath = this.getChunkPath(chunkHash);
+        await fs.mkdir(path.dirname(chunkPath), { recursive: true });
+        await fs.writeFile(chunkPath, chunk.data);
+        // Store metadata in Redis
+        const metadata = {
+            hash: chunkHash,
+            size: chunk.data.length,
+            index: chunk.index,
+            offset: chunk.offset,
+            fingerprint: chunk.fingerprint,
+            createdAt: new Date().toISOString(),
+            refCount: 1
+        };
+        await this.redis.hset('chunks:meta', chunkHash, JSON.stringify(metadata));
+        return chunkHash;
+    }
+    /**
+     * Store multiple chunks
+     */
+    async putChunks(chunks) {
+        return Promise.all(chunks.map(c => this.putChunk(c)));
+    }
+    /**
+     * Get a chunk
+     */
+    async getChunk(chunkHash) {
+        this.ensureInitialized();
+        const metaStr = await this.redis.hget('chunks:meta', chunkHash);
+        if (!metaStr)
+            return null;
+        const metadata = JSON.parse(metaStr);
+        try {
+            const chunkPath = this.getChunkPath(chunkHash);
+            const data = await fs.readFile(chunkPath);
+            if (!verifyHash(data, chunkHash)) {
+                throw new Error(`Chunk integrity failed: ${chunkHash}`);
+            }
+            return {
+                index: metadata.index,
+                offset: metadata.offset,
+                data: Buffer.from(data),
+                hash: chunkHash,
+                fingerprint: metadata.fingerprint
+            };
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                return null;
+            }
+            throw err;
+        }
+    }
+    /**
+     * Get multiple chunks
+     */
+    async getChunks(hashes) {
+        return Promise.all(hashes.map(h => this.getChunk(h)));
+    }
+    /**
+     * Check if chunk exists
+     */
+    async hasChunk(chunkHash) {
+        return (await this.redis.hexists('chunks:meta', chunkHash)) === 1;
+    }
+    /**
+     * Delete a chunk
+     */
+    async deleteChunk(chunkHash) {
+        this.ensureInitialized();
+        const metaStr = await this.redis.hget('chunks:meta', chunkHash);
+        if (!metaStr)
+            return false;
+        const metadata = JSON.parse(metaStr);
+        metadata.refCount--;
+        if (metadata.refCount <= 0) {
+            const chunkPath = this.getChunkPath(chunkHash);
+            try {
+                await fs.unlink(chunkPath);
+            }
+            catch (err) {
+                if (err.code !== 'ENOENT')
+                    throw err;
+            }
+            await this.redis.hdel('chunks:meta', chunkHash);
+        }
+        else {
+            await this.redis.hset('chunks:meta', chunkHash, JSON.stringify(metadata));
+        }
+        return true;
+    }
+    /**
+     * Get all chunk hashes
+     */
+    async getAllChunkHashes() {
+        return this.redis.hkeys('chunks:meta');
+    }
+    /**
+     * Get chunk stats
+     */
+    async getChunkStats() {
+        const all = await this.redis.hgetall('chunks:meta');
+        let totalChunks = 0;
+        let totalSize = 0;
+        for (const value of Object.values(all)) {
+            const meta = JSON.parse(value);
+            totalChunks++;
+            totalSize += meta.size;
+        }
+        return {
+            totalChunks,
+            totalSize,
+            avgChunkSize: totalChunks > 0 ? Math.round(totalSize / totalChunks) : 0
+        };
+    }
+    // ==================== Neuron Operations ====================
+    /**
+     * Create a new neuron
+     */
+    async createNeuron(input) {
+        this.ensureInitialized();
+        const now = new Date().toISOString();
+        const neuron = {
+            id: generateUUID(),
+            embedding: input.embedding,
+            chunkHashes: input.chunkHashes,
+            merkleRoot: input.merkleRoot,
+            metadata: {
+                createdAt: now,
+                updatedAt: now,
+                accessCount: 0,
+                lastAccessed: now,
+                sourceType: input.sourceType ?? 'unknown',
+                tags: input.tags ?? []
+            },
+            outgoingSynapses: [],
+            incomingSynapses: []
+        };
+        await this.putNeuron(neuron);
+        return neuron;
+    }
+    /**
+     * Store a neuron
+     */
+    async putNeuron(neuron) {
+        this.ensureInitialized();
+        const serialized = {
+            id: neuron.id,
+            embedding: Array.from(neuron.embedding),
+            chunkHashes: neuron.chunkHashes,
+            merkleRoot: neuron.merkleRoot,
+            metadata: neuron.metadata,
+            outgoingSynapses: neuron.outgoingSynapses,
+            incomingSynapses: neuron.incomingSynapses
+        };
+        await this.redis.hset('neurons', neuron.id, JSON.stringify(serialized));
+        await this.redis.hset('neurons:byRoot', neuron.merkleRoot, neuron.id);
+        // Index by tags
+        for (const tag of neuron.metadata.tags) {
+            await this.redis.sadd(`neurons:tag:${tag}`, neuron.id);
+        }
+    }
+    /**
+     * Get a neuron by ID
+     */
+    async getNeuron(id) {
+        this.ensureInitialized();
+        const data = await this.redis.hget('neurons', id);
+        if (!data)
+            return null;
+        const parsed = JSON.parse(data);
+        return {
+            ...parsed,
+            embedding: new Float32Array(parsed.embedding)
+        };
+    }
+    /**
+     * Get neuron by Merkle root
+     */
+    async getNeuronByMerkleRoot(merkleRoot) {
+        const id = await this.redis.hget('neurons:byRoot', merkleRoot);
+        if (!id)
+            return null;
+        return this.getNeuron(id);
+    }
+    /**
+     * Update a neuron
+     */
+    async updateNeuron(id, updates) {
+        const neuron = await this.getNeuron(id);
+        if (!neuron)
+            return null;
+        const updated = {
+            ...neuron,
+            ...updates,
+            id: neuron.id,
+            metadata: {
+                ...neuron.metadata,
+                ...updates.metadata,
+                updatedAt: new Date().toISOString()
+            }
+        };
+        await this.putNeuron(updated);
+        return updated;
+    }
+    /**
+     * Delete a neuron
+     */
+    async deleteNeuron(id) {
+        const neuron = await this.getNeuron(id);
+        if (!neuron)
+            return false;
+        // Delete synapses
+        for (const synapseId of [...neuron.outgoingSynapses, ...neuron.incomingSynapses]) {
+            await this.deleteSynapse(synapseId);
+        }
+        // Remove from indices
+        for (const tag of neuron.metadata.tags) {
+            await this.redis.srem(`neurons:tag:${tag}`, id);
+        }
+        await this.redis.hdel('neurons', id);
+        await this.redis.hdel('neurons:byRoot', neuron.merkleRoot);
+        return true;
+    }
+    /**
+     * Record neuron access
+     */
+    async recordNeuronAccess(id) {
+        const neuron = await this.getNeuron(id);
+        if (!neuron)
+            return;
+        neuron.metadata.accessCount++;
+        neuron.metadata.lastAccessed = new Date().toISOString();
+        await this.putNeuron(neuron);
+    }
+    /**
+     * Get all neuron IDs
+     */
+    async getAllNeuronIds() {
+        return this.redis.hkeys('neurons');
+    }
+    /**
+     * Get neurons by tag
+     */
+    async getNeuronsByTag(tag) {
+        const ids = await this.redis.smembers(`neurons:tag:${tag}`);
+        const neurons = [];
+        for (const id of ids) {
+            const neuron = await this.getNeuron(id);
+            if (neuron)
+                neurons.push(neuron);
+        }
+        return neurons;
+    }
+    /**
+     * Get neuron count
+     */
+    async getNeuronCount() {
+        return this.redis.hlen('neurons');
+    }
+    // ==================== Synapse Operations ====================
+    /**
+     * Create a synapse
+     */
+    async createSynapse(sourceId, targetId, type, weight = 1.0, bidirectional = false) {
+        this.ensureInitialized();
+        const source = await this.getNeuron(sourceId);
+        const target = await this.getNeuron(targetId);
+        if (!source || !target)
+            return null;
+        const now = new Date().toISOString();
+        const synapse = {
+            id: generateUUID(),
+            sourceId,
+            targetId,
+            type,
+            weight,
+            metadata: {
+                createdAt: now,
+                updatedAt: now,
+                activationCount: 0,
+                lastActivated: now,
+                bidirectional
+            }
+        };
+        await this.putSynapse(synapse);
+        // Update neurons
+        source.outgoingSynapses.push(synapse.id);
+        target.incomingSynapses.push(synapse.id);
+        await this.putNeuron(source);
+        await this.putNeuron(target);
+        // Create reverse if bidirectional
+        if (bidirectional) {
+            const reverse = {
+                id: generateUUID(),
+                sourceId: targetId,
+                targetId: sourceId,
+                type,
+                weight,
+                metadata: { createdAt: now, updatedAt: now, activationCount: 0, lastActivated: now, bidirectional: true }
+            };
+            await this.putSynapse(reverse);
+            target.outgoingSynapses.push(reverse.id);
+            source.incomingSynapses.push(reverse.id);
+            await this.putNeuron(source);
+            await this.putNeuron(target);
+        }
+        return synapse;
+    }
+    /**
+     * Store a synapse
+     */
+    async putSynapse(synapse) {
+        await this.redis.hset('synapses', synapse.id, JSON.stringify(synapse));
+        await this.redis.sadd(`synapses:source:${synapse.sourceId}`, synapse.id);
+        await this.redis.sadd(`synapses:target:${synapse.targetId}`, synapse.id);
+    }
+    /**
+     * Get a synapse
+     */
+    async getSynapse(id) {
+        const data = await this.redis.hget('synapses', id);
+        if (!data)
+            return null;
+        return JSON.parse(data);
+    }
+    /**
+     * Get outgoing synapses
+     */
+    async getOutgoingSynapses(neuronId) {
+        const ids = await this.redis.smembers(`synapses:source:${neuronId}`);
+        const synapses = [];
+        for (const id of ids) {
+            const synapse = await this.getSynapse(id);
+            if (synapse)
+                synapses.push(synapse);
+        }
+        return synapses;
+    }
+    /**
+     * Get incoming synapses
+     */
+    async getIncomingSynapses(neuronId) {
+        const ids = await this.redis.smembers(`synapses:target:${neuronId}`);
+        const synapses = [];
+        for (const id of ids) {
+            const synapse = await this.getSynapse(id);
+            if (synapse)
+                synapses.push(synapse);
+        }
+        return synapses;
+    }
+    /**
+     * Update synapse weight
+     */
+    async updateSynapseWeight(id, weight) {
+        const synapse = await this.getSynapse(id);
+        if (!synapse)
+            return null;
+        synapse.weight = weight;
+        synapse.metadata.updatedAt = new Date().toISOString();
+        await this.putSynapse(synapse);
+        return synapse;
+    }
+    /**
+     * Delete a synapse
+     */
+    async deleteSynapse(id) {
+        const synapse = await this.getSynapse(id);
+        if (!synapse)
+            return false;
+        await this.redis.hdel('synapses', id);
+        await this.redis.srem(`synapses:source:${synapse.sourceId}`, id);
+        await this.redis.srem(`synapses:target:${synapse.targetId}`, id);
+        // Update neurons
+        const source = await this.getNeuron(synapse.sourceId);
+        const target = await this.getNeuron(synapse.targetId);
+        if (source) {
+            source.outgoingSynapses = source.outgoingSynapses.filter(s => s !== id);
+            await this.putNeuron(source);
+        }
+        if (target) {
+            target.incomingSynapses = target.incomingSynapses.filter(s => s !== id);
+            await this.putNeuron(target);
+        }
+        return true;
+    }
+    /**
+     * Get synapse count
+     */
+    async getSynapseCount() {
+        return this.redis.hlen('synapses');
+    }
+    // ==================== Index Operations ====================
+    /**
+     * Save HNSW index
+     */
+    async saveIndex(name, indexData) {
+        await this.redis.set(`index:${name}`, JSON.stringify(indexData));
+    }
+    /**
+     * Load HNSW index
+     */
+    async loadIndex(name) {
+        const data = await this.redis.get(`index:${name}`);
+        if (!data)
+            return null;
+        return JSON.parse(data);
+    }
+    // ==================== Utilities ====================
+    getChunkPath(chunkHash) {
+        const prefix = chunkHash.slice(0, 2);
+        return path.join(this.chunkDir, prefix, chunkHash);
+    }
+    ensureInitialized() {
+        if (!this.initialized) {
+            throw new Error('RedisStore not initialized. Call init() first.');
+        }
+    }
+    /**
+     * Get overall stats
+     */
+    async getStats() {
+        const chunkStats = await this.getChunkStats();
+        return {
+            chunks: { total: chunkStats.totalChunks, size: chunkStats.totalSize },
+            neurons: await this.getNeuronCount(),
+            synapses: await this.getSynapseCount()
+        };
+    }
+}
+// Export singleton factory
+export function createRedisStore(options) {
+    return new RedisStore(options);
+}
+//# sourceMappingURL=redis-store.js.map