@ninebix/nmt-system 1.0.0

package/dist/src/core/chunk-engine.js

@@ -0,0 +1,192 @@
+/**
+ * Chunk Engine - Data segmentation and reassembly
+ * @module core/chunk-engine
+ */
+import { hash } from '../utils/hash.js';
+/** Default chunk size: 4KB */
+const DEFAULT_CHUNK_SIZE = 4096;
+/** Default overlap between chunks */
+const DEFAULT_OVERLAP = 256;
+/** CDC minimum chunk size */
+const CDC_MIN_CHUNK = 2048;
+/** CDC maximum chunk size */
+const CDC_MAX_CHUNK = 65536;
+/** Rabin fingerprint polynomial */
+const RABIN_POLYNOMIAL = 0x3da3358b4dc173n;
+/** Rabin fingerprint mask for boundary detection */
+const RABIN_MASK = 0x1fffn;
+/** Rabin window size */
+const RABIN_WINDOW = 48;
+/**
+ * ChunkEngine class for data segmentation
+ */
+export class ChunkEngine {
+    options;
+    constructor(options = {}) {
+        this.options = {
+            chunkSize: options.chunkSize ?? DEFAULT_CHUNK_SIZE,
+            overlap: options.overlap ?? DEFAULT_OVERLAP,
+            useCDC: options.useCDC ?? false,
+            minChunkSize: options.minChunkSize ?? CDC_MIN_CHUNK,
+            maxChunkSize: options.maxChunkSize ?? CDC_MAX_CHUNK
+        };
+    }
+    /**
+     * Chunk data using the configured method
+     * @param data - Data to chunk
+     * @returns Array of chunks
+     */
+    chunk(data) {
+        if (this.options.useCDC) {
+            return this.cdcChunk(data);
+        }
+        return this.fixedChunk(data);
+    }
+    /**
+     * Fixed-size chunking
+     * @param data - Data to chunk
+     * @param size - Chunk size (default from options)
+     * @returns Array of chunks
+     */
+    fixedChunk(data, size) {
+        const chunkSize = size ?? this.options.chunkSize;
+        const chunks = [];
+        for (let offset = 0; offset < data.length; offset += chunkSize) {
+            const end = Math.min(offset + chunkSize, data.length);
+            const chunkData = data.subarray(offset, end);
+            chunks.push({
+                index: chunks.length,
+                offset,
+                data: Buffer.from(chunkData),
+                hash: hash(chunkData)
+            });
+        }
+        return chunks;
+    }
+    /**
+     * Content-Defined Chunking using Rabin fingerprints
+     * @param data - Data to chunk
+     * @returns Array of variable-size chunks
+     */
+    cdcChunk(data) {
+        const chunks = [];
+        const { minChunkSize, maxChunkSize } = this.options;
+        let fingerprint = 0n;
+        let chunkStart = 0;
+        for (let i = 0; i < data.length; i++) {
+            // Update fingerprint with rolling hash
+            fingerprint = this.updateFingerprint(fingerprint, data[i]);
+            const chunkLength = i - chunkStart + 1;
+            // Check boundary conditions
+            const isBoundary = (fingerprint & RABIN_MASK) === 0n;
+            const meetsMinSize = chunkLength >= minChunkSize;
+            const exceedsMaxSize = chunkLength >= maxChunkSize;
+            const isEndOfData = i === data.length - 1;
+            if ((isBoundary && meetsMinSize) || exceedsMaxSize || isEndOfData) {
+                const chunkData = data.subarray(chunkStart, i + 1);
+                chunks.push({
+                    index: chunks.length,
+                    offset: chunkStart,
+                    data: Buffer.from(chunkData),
+                    hash: hash(chunkData),
+                    fingerprint: Number(fingerprint & 0xffffffffn)
+                });
+                chunkStart = i + 1;
+                fingerprint = 0n;
+            }
+        }
+        return chunks;
+    }
+    /**
+     * Update Rabin fingerprint with new byte
+     */
+    updateFingerprint(fingerprint, byte) {
+        return ((fingerprint << 1n) ^ BigInt(byte)) % RABIN_POLYNOMIAL;
+    }
+    /**
+     * Merge chunks back into original data
+     * @param chunks - Array of chunks in order
+     * @returns Merged buffer
+     */
+    merge(chunks) {
+        // Sort by index to ensure correct order
+        const sorted = [...chunks].sort((a, b) => a.index - b.index);
+        // Calculate total size
+        const totalSize = sorted.reduce((sum, c) => sum + c.data.length, 0);
+        const result = Buffer.allocUnsafe(totalSize);
+        let position = 0;
+        for (const chunk of sorted) {
+            chunk.data.copy(result, position);
+            position += chunk.data.length;
+        }
+        return result;
+    }
+    /**
+     * Verify chunk integrity
+     * @param chunk - Chunk to verify
+     * @returns true if hash matches
+     */
+    verifyChunk(chunk) {
+        return hash(chunk.data) === chunk.hash;
+    }
+    /**
+     * Verify all chunks in array
+     * @param chunks - Chunks to verify
+     * @returns true if all hashes match
+     */
+    verifyAllChunks(chunks) {
+        return chunks.every(chunk => this.verifyChunk(chunk));
+    }
+    /**
+     * Find duplicate chunks by hash
+     * @param chunks - Chunks to deduplicate
+     * @returns Deduplication result
+     */
+    deduplicate(chunks) {
+        const hashToIndices = new Map();
+        const unique = [];
+        let savedBytes = 0;
+        for (const chunk of chunks) {
+            const indices = hashToIndices.get(chunk.hash);
+            if (indices) {
+                indices.push(chunk.index);
+                savedBytes += chunk.data.length;
+            }
+            else {
+                hashToIndices.set(chunk.hash, [chunk.index]);
+                unique.push(chunk);
+            }
+        }
+        const duplicates = new Map();
+        for (const [h, indices] of hashToIndices) {
+            if (indices.length > 1) {
+                duplicates.set(h, indices);
+            }
+        }
+        return { unique, duplicates, savedBytes };
+    }
+    /**
+     * Get chunk statistics
+     */
+    getStats(chunks) {
+        if (chunks.length === 0) {
+            return { count: 0, totalSize: 0, avgSize: 0, minSize: 0, maxSize: 0 };
+        }
+        const sizes = chunks.map(c => c.data.length);
+        const totalSize = sizes.reduce((a, b) => a + b, 0);
+        return {
+            count: chunks.length,
+            totalSize,
+            avgSize: Math.round(totalSize / chunks.length),
+            minSize: Math.min(...sizes),
+            maxSize: Math.max(...sizes)
+        };
+    }
+}
+/**
+ * Create a ChunkEngine instance with default options
+ */
+export function createChunkEngine(options) {
+    return new ChunkEngine(options);
+}
+//# sourceMappingURL=chunk-engine.js.map

package/dist/src/core/chunk-engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-engine.js","sourceRoot":"","sources":["../../../src/core/chunk-engine.ts"],"names":[],"mappings":"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"}

package/dist/src/core/dynamic-embedding.d.ts

@@ -0,0 +1,327 @@
+/**
+ * Dynamic Embedding System - Infinite Dimension Expansion
+ *
+ * Based on Probabilistic Ontology Framework:
+ * - Embeddings are not fixed at 384 dimensions
+ * - New concepts can expand the embedding space
+ * - Dimensions are semantic, not arbitrary
+ *
+ * @module core/dynamic-embedding
+ */
+import type { UUID } from '../types/index.js';
+/**
+ * Dynamic embedding that can grow
+ */
+export interface DynamicEmbedding {
+    id: UUID;
+    dimensions: Map<string, number>;
+    baseDimension: number;
+    createdAt: string;
+    expandedAt?: string;
+}
+/**
+ * Dimension metadata
+ */
+export interface DimensionInfo {
+    name: string;
+    description: string;
+    createdAt: string;
+    sourceNeuronId?: UUID;
+    semanticCategory: string;
+    usageCount: number;
+}
+/**
+ * Embedding expansion result
+ */
+export interface ExpansionResult {
+    originalDimensions: number;
+    newDimensions: number;
+    addedDimensions: string[];
+    reason: string;
+}
+/**
+ * Dynamic Embedding Manager Options
+ */
+export interface DynamicEmbeddingOptions {
+    baseDimension?: number;
+    maxDimensions?: number;
+    expansionThreshold?: number;
+    enableAutoExpansion?: boolean;
+}
+/**
+ * Dynamic Embedding Manager - Infinite Dimension Expansion
+ *
+ * Manages embeddings that can dynamically expand when new concepts
+ * cannot be adequately represented in current dimensions. This enables
+ * the system to grow its semantic space organically.
+ *
+ * Key Concepts:
+ * - **Base Dimensions**: Initial 384 dimensions covering standard semantics
+ * - **Dimension Expansion**: New dimensions added for novel concepts
+ * - **Semantic Categories**: Dimensions organized by type (semantic, syntactic, etc.)
+ * - **Auto-Expansion**: System automatically expands when similarity is too low
+ *
+ * @example
+ * ```typescript
+ * const manager = new DynamicEmbeddingManager({
+ *   baseDimension: 384,
+ *   maxDimensions: 10000,
+ *   enableAutoExpansion: true
+ * });
+ *
+ * // Create dynamic embedding from fixed array
+ * const dynEmb = manager.createFromFixed('emb-1', fixedEmbedding);
+ *
+ * // Auto-expand for new concept
+ * const expansion = manager.autoExpand(dynEmb, 'quantum computing applications');
+ * if (expansion) {
+ *   console.log(`Added ${expansion.addedDimensions.length} dimensions`);
+ * }
+ *
+ * // Calculate similarity between dynamic embeddings
+ * const sim = manager.similarity(dynEmbA, dynEmbB);
+ *
+ * // Get dimensions by category
+ * const semanticDims = manager.getDimensionsByCategory('semantic');
+ * ```
+ *
+ * @see {@link DynamicEmbedding} for embedding structure
+ * @see {@link DimensionInfo} for dimension metadata
+ */
+export declare class DynamicEmbeddingManager {
+    private baseDimension;
+    private maxDimensions;
+    private expansionThreshold;
+    private autoExpansion;
+    private dimensionRegistry;
+    private dimensionOrder;
+    private embeddings;
+    private semanticCategories;
+    constructor(options?: DynamicEmbeddingOptions);
+    /**
+     * Create a dynamic embedding from a fixed-size array.
+     *
+     * Maps each element of the fixed array to a named dimension,
+     * enabling future expansion while maintaining compatibility
+     * with standard embedding operations.
+     *
+     * @param id - Unique identifier for the embedding
+     * @param fixedEmbedding - Standard fixed-size Float32Array embedding
+     * @returns New DynamicEmbedding with named dimensions
+     *
+     * @example
+     * ```typescript
+     * const fixed = new Float32Array(384).fill(0.1);
+     * const dynamic = manager.createFromFixed('my-embedding', fixed);
+     * console.log(`Dimensions: ${dynamic.dimensions.size}`);
+     * ```
+     */
+    createFromFixed(id: UUID, fixedEmbedding: Float32Array): DynamicEmbedding;
+    /**
+     * Convert dynamic embedding to fixed-size array.
+     *
+     * Projects the dynamic embedding back to a fixed-size array,
+     * useful for compatibility with standard ML operations.
+     *
+     * @param embedding - The dynamic embedding to convert
+     * @param targetSize - Optional target size (defaults to current dimension count)
+     * @returns Fixed-size Float32Array embedding
+     *
+     * @example
+     * ```typescript
+     * const fixed = manager.toFixed(dynamicEmbedding, 384);
+     * // Use with standard similarity functions
+     * const sim = cosineSimilarity(fixed, otherFixed);
+     * ```
+     */
+    toFixed(embedding: DynamicEmbedding, targetSize?: number): Float32Array;
+    /**
+     * Expand embedding with new dimensions.
+     *
+     * Manually adds new dimensions to an embedding. Use this when
+     * you need explicit control over dimension expansion. For
+     * automatic expansion, use {@link autoExpand} instead.
+     *
+     * @param embedding - The embedding to expand
+     * @param newDimensions - Map of dimension names to values
+     * @param reason - Human-readable reason for expansion
+     * @returns Expansion result with statistics
+     *
+     * @example
+     * ```typescript
+     * const result = manager.expandEmbedding(
+     *   myEmbedding,
+     *   new Map([['quantum_coherence', 0.8], ['superposition', 0.6]]),
+     *   'Quantum computing concepts'
+     * );
+     * console.log(`Added: ${result.addedDimensions.join(', ')}`);
+     * ```
+     */
+    expandEmbedding(embedding: DynamicEmbedding, newDimensions: Map<string, number>, reason: string): ExpansionResult;
+    /**
+     * Check if embedding needs expansion for a concept
+     */
+    needsExpansion(embedding: DynamicEmbedding, conceptVector: Float32Array, similarityThreshold?: number): boolean;
+    /**
+     * Auto-expand embedding based on concept requirements.
+     *
+     * Automatically extracts semantic dimensions from a concept
+     * description and adds them to the embedding. Respects the
+     * maximum dimension limit.
+     *
+     * @param embedding - The embedding to expand
+     * @param conceptDescription - Text describing the new concept
+     * @param conceptVector - Optional vector representing the concept
+     * @returns Expansion result, or null if disabled/at limit
+     *
+     * @example
+     * ```typescript
+     * const result = manager.autoExpand(
+     *   embedding,
+     *   'Machine learning optimization techniques including gradient descent and backpropagation'
+     * );
+     *
+     * if (result) {
+     *   console.log(`Now have ${result.newDimensions} dimensions`);
+     * }
+     * ```
+     */
+    autoExpand(embedding: DynamicEmbedding, conceptDescription: string, conceptVector?: Float32Array): ExpansionResult | null;
+    /**
+     * Register a new dimension.
+     *
+     * Adds a new dimension to the global registry. Each dimension
+     * has metadata including semantic category and usage tracking.
+     *
+     * @param name - Unique dimension name
+     * @param info - Dimension metadata including category and description
+     *
+     * @example
+     * ```typescript
+     * manager.registerDimension('temporal_causality', {
+     *   name: 'temporal_causality',
+     *   description: 'Cause-effect relationships over time',
+     *   createdAt: new Date().toISOString(),
+     *   semanticCategory: 'causal',
+     *   usageCount: 0
+     * });
+     * ```
+     */
+    registerDimension(name: string, info: DimensionInfo): void;
+    /**
+     * Get dimensions by semantic category
+     */
+    getDimensionsByCategory(category: string): string[];
+    /**
+     * Calculate similarity between two dynamic embeddings.
+     *
+     * Computes cosine similarity over the union of all dimensions.
+     * Missing dimensions in either embedding are treated as 0.
+     *
+     * @param a - First dynamic embedding
+     * @param b - Second dynamic embedding
+     * @returns Cosine similarity (-1 to 1)
+     *
+     * @example
+     * ```typescript
+     * const sim = manager.similarity(embeddingA, embeddingB);
+     * console.log(`Similarity: ${(sim * 100).toFixed(1)}%`);
+     * ```
+     */
+    similarity(a: DynamicEmbedding, b: DynamicEmbedding): number;
+    /**
+     * Project embedding to a subspace of specific dimensions
+     */
+    project(embedding: DynamicEmbedding, dimensionNames: string[]): Map<string, number>;
+    /**
+     * Get the current total dimension count
+     */
+    getCurrentDimensionCount(): number;
+    /**
+     * Get embedding by ID
+     */
+    getEmbedding(id: UUID): DynamicEmbedding | undefined;
+    /**
+     * Get statistics
+     */
+    getStats(): {
+        totalDimensions: number;
+        baseDimensions: number;
+        expandedDimensions: number;
+        categories: number;
+        embeddings: number;
+    };
+    /**
+     * Serialize dimension registry for persistence.
+     *
+     * Converts the dimension registry, order, and categories to
+     * a JSON-serializable format.
+     *
+     * @returns Serialized dimension state
+     * @see {@link loadDimensions} for restoring state
+     */
+    serializeDimensions(): object;
+    /**
+     * Load dimension registry from serialized data
+     */
+    loadDimensions(data: {
+        order: string[];
+        registry: Record<string, DimensionInfo>;
+        categories: Record<string, string[]>;
+    }): void;
+    /**
+     * Serialize all embeddings for persistence.
+     *
+     * Converts all stored embeddings to a JSON-serializable format.
+     * Dimension Maps are converted to plain objects.
+     *
+     * @returns Serialized embeddings array
+     * @see {@link loadEmbeddings} for restoring state
+     */
+    serializeEmbeddings(): object;
+    /**
+     * Load embeddings from serialized data
+     */
+    loadEmbeddings(data: {
+        embeddings: Array<{
+            id: string;
+            dimensions: Record<string, number>;
+            baseDimension: number;
+            createdAt: string;
+            expandedAt?: string;
+        }>;
+    }): void;
+    /**
+     * Serialize complete state (dimensions + embeddings).
+     *
+     * Convenience method that serializes both the dimension registry
+     * and all stored embeddings in a single call.
+     *
+     * @returns Complete serialized state
+     * @see {@link loadAll} for restoring state
+     */
+    serializeAll(): object;
+    /**
+     * Load complete state (dimensions + embeddings)
+     */
+    loadAll(data: {
+        dimensions: {
+            order: string[];
+            registry: Record<string, DimensionInfo>;
+            categories: Record<string, string[]>;
+        };
+        embeddings: {
+            embeddings: Array<any>;
+        };
+    }): void;
+    private initializeBaseDimensions;
+    private inferCategory;
+    private extractSemanticDimensions;
+    private extractKeywords;
+    private calculateKeywordImportance;
+}
+/**
+ * Create a DynamicEmbeddingManager instance
+ */
+export declare function createDynamicEmbeddingManager(options?: DynamicEmbeddingOptions): DynamicEmbeddingManager;
+//# sourceMappingURL=dynamic-embedding.d.ts.map

package/dist/src/core/dynamic-embedding.d.ts.map

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