@soulcraft/brainy 3.50.1 → 4.0.0

package/dist/api/ConfigAPI.js

@@ -33,9 +33,16 @@ export class ConfigAPI {
         };
         // Store in cache
         this.configCache.set(key, entry);
-        // Persist to storage
+        // v4.0.0: Persist to storage as NounMetadata
         const configId = this.CONFIG_NOUN_PREFIX + key;
-        await this.storage.saveMetadata(configId, entry);
+        const nounMetadata = {
+            noun: 'config',
+            ...entry,
+            service: 'config',
+            createdAt: entry.createdAt,
+            updatedAt: entry.updatedAt
+        };
+        await this.storage.saveNounMetadata(configId, nounMetadata);
     }
     /**
      * Get a configuration value with optional decryption
@@ -47,11 +54,24 @@ export class ConfigAPI {
         // If not in cache, load from storage
         if (!entry) {
             const configId = this.CONFIG_NOUN_PREFIX + key;
-            const metadata = await this.storage.getMetadata(configId);
+            const metadata = await this.storage.getNounMetadata(configId);
             if (!metadata) {
                 return defaultValue;
             }
-            entry = metadata;
+            // v4.0.0: Extract ConfigEntry from NounMetadata
+            const createdAtVal = typeof metadata.createdAt === 'object' && metadata.createdAt !== null && 'seconds' in metadata.createdAt
+                ? metadata.createdAt.seconds * 1000 + Math.floor((metadata.createdAt.nanoseconds || 0) / 1000000)
+                : (metadata.createdAt || Date.now());
+            const updatedAtVal = typeof metadata.updatedAt === 'object' && metadata.updatedAt !== null && 'seconds' in metadata.updatedAt
+                ? metadata.updatedAt.seconds * 1000 + Math.floor((metadata.updatedAt.nanoseconds || 0) / 1000000)
+                : (metadata.updatedAt || createdAtVal);
+            entry = {
+                key: metadata.key,
+                value: metadata.value,
+                encrypted: metadata.encrypted,
+                createdAt: createdAtVal,
+                updatedAt: updatedAtVal
+            };
             this.configCache.set(key, entry);
         }
         let value = entry.value;
@@ -77,24 +97,20 @@ export class ConfigAPI {
     async delete(key) {
         // Remove from cache
         this.configCache.delete(key);
-        // Remove from storage
+        // v4.0.0: Remove from storage
         const configId = this.CONFIG_NOUN_PREFIX + key;
-        await this.storage.saveMetadata(configId, null);
+        await this.storage.deleteNounMetadata(configId);
     }
     /**
      * List all configuration keys
      */
     async list() {
-        // Get all metadata keys from storage
-        const allMetadata = await this.storage.getMetadata('');
-        if (!allMetadata || typeof allMetadata !== 'object') {
-            return [];
-        }
-        // Filter for config keys
+        // v4.0.0: Get all nouns and filter for config entries
+        const result = await this.storage.getNouns({ pagination: { limit: 10000 } });
         const configKeys = [];
-        for (const key of Object.keys(allMetadata)) {
-            if (key.startsWith(this.CONFIG_NOUN_PREFIX)) {
-                configKeys.push(key.substring(this.CONFIG_NOUN_PREFIX.length));
+        for (const noun of result.items) {
+            if (noun.id.startsWith(this.CONFIG_NOUN_PREFIX)) {
+                configKeys.push(noun.id.substring(this.CONFIG_NOUN_PREFIX.length));
             }
         }
         return configKeys;
@@ -107,7 +123,7 @@ export class ConfigAPI {
             return true;
         }
         const configId = this.CONFIG_NOUN_PREFIX + key;
-        const metadata = await this.storage.getMetadata(configId);
+        const metadata = await this.storage.getNounMetadata(configId);
         return metadata !== null && metadata !== undefined;
     }
     /**
@@ -143,7 +159,15 @@ export class ConfigAPI {
         for (const [key, entry] of Object.entries(config)) {
             this.configCache.set(key, entry);
             const configId = this.CONFIG_NOUN_PREFIX + key;
-            await this.storage.saveMetadata(configId, entry);
+            // v4.0.0: Convert ConfigEntry to NounMetadata
+            const nounMetadata = {
+                noun: 'config',
+                ...entry,
+                service: 'config',
+                createdAt: entry.createdAt,
+                updatedAt: entry.updatedAt
+            };
+            await this.storage.saveNounMetadata(configId, nounMetadata);
         }
     }
     /**
@@ -154,11 +178,24 @@ export class ConfigAPI {
             return this.configCache.get(key);
         }
         const configId = this.CONFIG_NOUN_PREFIX + key;
-        const metadata = await this.storage.getMetadata(configId);
+        const metadata = await this.storage.getNounMetadata(configId);
         if (!metadata) {
             return null;
         }
-        const entry = metadata;
+        // v4.0.0: Extract ConfigEntry from NounMetadata
+        const createdAtVal = typeof metadata.createdAt === 'object' && metadata.createdAt !== null && 'seconds' in metadata.createdAt
+            ? metadata.createdAt.seconds * 1000 + Math.floor((metadata.createdAt.nanoseconds || 0) / 1000000)
+            : (metadata.createdAt || Date.now());
+        const updatedAtVal = typeof metadata.updatedAt === 'object' && metadata.updatedAt !== null && 'seconds' in metadata.updatedAt
+            ? metadata.updatedAt.seconds * 1000 + Math.floor((metadata.updatedAt.nanoseconds || 0) / 1000000)
+            : (metadata.updatedAt || createdAtVal);
+        const entry = {
+            key: metadata.key,
+            value: metadata.value,
+            encrypted: metadata.encrypted,
+            createdAt: createdAtVal,
+            updatedAt: updatedAtVal
+        };
         this.configCache.set(key, entry);
         return entry;
     }

package/dist/api/DataAPI.js

@@ -41,8 +41,8 @@ export class DataAPI {
                 id: verb.id,
                 from: verb.sourceId,
                 to: verb.targetId,
-                type: (verb.verb || verb.type),
-                weight: verb.weight || 1.0,
+                type: verb.verb,
+                weight: verb.metadata?.weight || 1.0,
                 metadata: verb.metadata
             });
         }
@@ -91,16 +91,18 @@ export class DataAPI {
         // Restore entities
         for (const entity of backup.entities) {
             try {
+                // v4.0.0: Prepare noun and metadata separately
                 const noun = {
                     id: entity.id,
                     vector: entity.vector || new Array(384).fill(0), // Default vector if missing
                     connections: new Map(),
-                    level: 0,
-                    metadata: {
-                        ...entity.metadata,
-                        noun: entity.type,
-                        service: entity.service
-                    }
+                    level: 0
+                };
+                const metadata = {
+                    ...entity.metadata,
+                    noun: entity.type,
+                    service: entity.service,
+                    createdAt: Date.now()
                 };
                 // Check if entity exists when merging
                 if (merge) {
@@ -110,6 +112,7 @@ export class DataAPI {
                     }
                 }
                 await this.storage.saveNoun(noun);
+                await this.storage.saveNounMetadata(entity.id, metadata);
             }
             catch (error) {
                 console.error(`Failed to restore entity ${entity.id}:`, error);
@@ -127,17 +130,18 @@ export class DataAPI {
                 }
                 // Compute relation vector as average of source and target
                 const relationVector = sourceNoun.vector.map((v, i) => (v + targetNoun.vector[i]) / 2);
+                // v4.0.0: Prepare verb and metadata separately
                 const verb = {
                     id: relation.id,
                     vector: relationVector,
-                    sourceId: relation.from,
-                    targetId: relation.to,
-                    source: sourceNoun.metadata?.noun || NounType.Thing,
-                    target: targetNoun.metadata?.noun || NounType.Thing,
+                    connections: new Map(),
                     verb: relation.type,
-                    type: relation.type,
+                    sourceId: relation.from,
+                    targetId: relation.to
+                };
+                const verbMetadata = {
                     weight: relation.weight,
-                    metadata: relation.metadata,
+                    ...relation.metadata,
                     createdAt: Date.now()
                 };
                 // Check if relation exists when merging
@@ -148,6 +152,7 @@ export class DataAPI {
                     }
                 }
                 await this.storage.saveVerb(verb);
+                await this.storage.saveVerbMetadata(relation.id, verbMetadata);
             }
             catch (error) {
                 console.error(`Failed to restore relation ${relation.id}:`, error);
@@ -253,15 +258,16 @@ export class DataAPI {
                         if (validate) {
                             this.validateImportItem(mapped);
                         }
-                        // Save as entity
+                        // v4.0.0: Save entity - separate vector and metadata
+                        const id = mapped.id || this.generateId();
                         const noun = {
-                            id: mapped.id || this.generateId(),
+                            id,
                             vector: mapped.vector || new Array(384).fill(0),
                             connections: new Map(),
-                            level: 0,
-                            metadata: mapped
+                            level: 0
                         };
                         await this.storage.saveNoun(noun);
+                        await this.storage.saveNounMetadata(id, { ...mapped, createdAt: Date.now() });
                         result.successful++;
                     }
                     catch (error) {

package/dist/augmentations/storageAugmentations.d.ts

@@ -115,6 +115,30 @@ export declare class GCSStorageAugmentation extends StorageAugmentation {
     provideStorage(): Promise<StorageAdapter>;
     protected onInitialize(): Promise<void>;
 }
+/**
+ * Azure Blob Storage Augmentation - Microsoft Azure
+ */
+export declare class AzureStorageAugmentation extends StorageAugmentation {
+    readonly name = "azure-storage";
+    protected config: {
+        containerName: string;
+        accountName?: string;
+        accountKey?: string;
+        connectionString?: string;
+        sasToken?: string;
+        cacheConfig?: any;
+    };
+    constructor(config: {
+        containerName: string;
+        accountName?: string;
+        accountKey?: string;
+        connectionString?: string;
+        sasToken?: string;
+        cacheConfig?: any;
+    });
+    provideStorage(): Promise<StorageAdapter>;
+    protected onInitialize(): Promise<void>;
+}
 /**
  * Auto-select the best storage augmentation for the environment
  * Maintains zero-config philosophy

package/dist/augmentations/storageAugmentations.js

@@ -9,6 +9,7 @@ import { MemoryStorage } from '../storage/adapters/memoryStorage.js';
 import { OPFSStorage } from '../storage/adapters/opfsStorage.js';
 import { S3CompatibleStorage } from '../storage/adapters/s3CompatibleStorage.js';
 import { R2Storage } from '../storage/adapters/r2Storage.js';
+import { AzureBlobStorage } from '../storage/adapters/azureBlobStorage.js';
 /**
  * Memory Storage Augmentation - Fast in-memory storage
  */
@@ -338,6 +339,27 @@ export class GCSStorageAugmentation extends StorageAugmentation {
         this.log(`GCS storage initialized with bucket ${this.config.bucketName}`);
     }
 }
+/**
+ * Azure Blob Storage Augmentation - Microsoft Azure
+ */
+export class AzureStorageAugmentation extends StorageAugmentation {
+    constructor(config) {
+        super();
+        this.name = 'azure-storage';
+        this.config = config;
+    }
+    async provideStorage() {
+        const storage = new AzureBlobStorage({
+            ...this.config
+        });
+        this.storageAdapter = storage;
+        return storage;
+    }
+    async onInitialize() {
+        await this.storageAdapter.init();
+        this.log(`Azure Blob Storage initialized with container ${this.config.containerName}`);
+    }
+}
 /**
  * Auto-select the best storage augmentation for the environment
  * Maintains zero-config philosophy

package/dist/brainy.js

@@ -282,14 +282,14 @@ export class Brainy {
                 service: params.service,
                 createdAt: Date.now()
             };
-            // Save to storage
+            // v4.0.0: Save vector and metadata separately
             await this.storage.saveNoun({
                 id,
                 vector,
                 connections: new Map(),
-                level: 0,
-                metadata
+                level: 0
             });
+            await this.storage.saveNounMetadata(id, metadata);
             // Add to metadata index for fast filtering
             await this.metadataIndex.addToIndex(id, metadata);
             return id;
@@ -446,13 +446,14 @@ export class Brainy {
                 createdAt: existing.createdAt,
                 updatedAt: Date.now()
             };
+            // v4.0.0: Save vector and metadata separately
             await this.storage.saveNoun({
                 id: params.id,
                 vector,
                 connections: new Map(),
-                level: 0,
-                metadata: updatedMetadata
+                level: 0
             });
+            await this.storage.saveNounMetadata(params.id, updatedMetadata);
             // Update metadata index - remove old entry and add new one
             await this.metadataIndex.removeFromIndex(params.id, existing.metadata);
             await this.metadataIndex.addToIndex(params.id, updatedMetadata);
@@ -635,7 +636,7 @@ export class Brainy {
         // Bug #1 showed incrementing verb counts (7→8→9...) indicating duplicates
         const existingVerbs = await this.storage.getVerbsBySource(params.from);
         const duplicate = existingVerbs.find(v => v.targetId === params.to &&
-            v.type === params.type);
+            v.verb === params.type);
         if (duplicate) {
             // Relationship already exists - return existing ID instead of creating duplicate
             console.log(`[DEBUG] Skipping duplicate relationship: ${params.from} → ${params.to} (${params.type})`);
@@ -646,7 +647,13 @@ export class Brainy {
         // Compute relationship vector (average of entities)
         const relationVector = fromEntity.vector.map((v, i) => (v + toEntity.vector[i]) / 2);
         return this.augmentationRegistry.execute('relate', params, async () => {
-            // Save to storage
+            // v4.0.0: Prepare verb metadata
+            const verbMetadata = {
+                weight: params.weight ?? 1.0,
+                ...(params.metadata || {}),
+                createdAt: Date.now()
+            };
+            // Save to storage (v4.0.0: vector and metadata separately)
             const verb = {
                 id,
                 vector: relationVector,
@@ -660,7 +667,15 @@ export class Brainy {
                 metadata: params.metadata,
                 createdAt: Date.now()
             };
-            await this.storage.saveVerb(verb);
+            await this.storage.saveVerb({
+                id,
+                vector: relationVector,
+                connections: new Map(),
+                verb: params.type,
+                sourceId: params.from,
+                targetId: params.to
+            });
+            await this.storage.saveVerbMetadata(id, verbMetadata);
             // Add to graph index for O(1) lookups
             await this.graphIndex.addVerb(verb);
             // Create bidirectional if requested
@@ -674,7 +689,15 @@ export class Brainy {
                     source: toEntity.type,
                     target: fromEntity.type
                 };
-                await this.storage.saveVerb(reverseVerb);
+                await this.storage.saveVerb({
+                    id: reverseId,
+                    vector: relationVector,
+                    connections: new Map(),
+                    verb: params.type,
+                    sourceId: params.to,
+                    targetId: params.from
+                });
+                await this.storage.saveVerbMetadata(reverseId, verbMetadata);
                 // Add reverse relationship to graph index too
                 await this.graphIndex.addVerb(reverseVerb);
             }

package/dist/cli/commands/core.d.ts

@@ -37,10 +37,6 @@ interface RelateOptions extends CoreOptions {
     weight?: string;
     metadata?: string;
 }
-interface ImportOptions extends CoreOptions {
-    format?: 'json' | 'csv' | 'jsonl';
-    batchSize?: string;
-}
 interface ExportOptions extends CoreOptions {
     format?: 'json' | 'csv' | 'jsonl';
 }
@@ -48,23 +44,37 @@ export declare const coreCommands: {
     /**
      * Add data to the neural database
      */
-    add(text: string, options: AddOptions): Promise<void>;
+    add(text: string | undefined, options: AddOptions): Promise<void>;
     /**
      * Search the neural database with Triple Intelligence™
      */
-    search(query: string, options: SearchOptions): Promise<void>;
+    search(query: string | undefined, options: SearchOptions): Promise<void>;
     /**
      * Get item by ID
      */
-    get(id: string, options: GetOptions): Promise<void>;
+    get(id: string | undefined, options: GetOptions): Promise<void>;
     /**
      * Create relationship between items
      */
-    relate(source: string, verb: string, target: string, options: RelateOptions): Promise<void>;
+    relate(source: string | undefined, verb: string | undefined, target: string | undefined, options: RelateOptions): Promise<void>;
+    /**
+     * Update an existing entity
+     */
+    update(id: string | undefined, options: AddOptions & {
+        content?: string;
+    }): Promise<void>;
+    /**
+     * Delete an entity
+     */
+    deleteEntity(id: string | undefined, options: CoreOptions & {
+        force?: boolean;
+    }): Promise<void>;
     /**
-     * Import data from file
+     * Remove a relationship
      */
-    import(file: string, options: ImportOptions): Promise<void>;
+    unrelate(id: string | undefined, options: CoreOptions & {
+        force?: boolean;
+    }): Promise<void>;
     /**
      * Export database
      */