@soulcraft/brainy 5.3.1 → 5.3.3

package/dist/storage/baseStorage.js

@@ -221,9 +221,20 @@ export class BaseStorage extends BaseStorageAdapter {
         // Check if main branch exists, create if not
         const mainRef = await this.refManager.getRef('main');
         if (!mainRef) {
-            // Create initial commit (empty tree)
+            // Create initial commit with empty tree
             const emptyTreeHash = '0000000000000000000000000000000000000000000000000000000000000000';
-            await this.refManager.createBranch('main', emptyTreeHash, {
+            // Import CommitBuilder
+            const { CommitBuilder } = await import('./cow/CommitObject.js');
+            // Create initial commit object
+            const initialCommitHash = await CommitBuilder.create(this.blobStorage)
+                .tree(emptyTreeHash)
+                .parent(null)
+                .message('Initial commit')
+                .author('system')
+                .timestamp(Date.now())
+                .build();
+            // Create main branch pointing to initial commit
+            await this.refManager.createBranch('main', initialCommitHash, {
                 description: 'Initial branch',
                 author: 'system'
             });

package/dist/storage/cow/BlobStorage.js

@@ -132,10 +132,12 @@ export class BlobStorage {
         }
         else {
             // Small blob: single write
-            await this.adapter.put(`blob:${hash}`, finalData);
+            const prefix = options.type || 'blob';
+            await this.adapter.put(`${prefix}:${hash}`, finalData);
         }
         // Write metadata
-        await this.adapter.put(`blob-meta:${hash}`, Buffer.from(JSON.stringify(metadata)));
+        const prefix = options.type || 'blob';
+        await this.adapter.put(`${prefix}-meta:${hash}`, Buffer.from(JSON.stringify(metadata)));
         // Update cache (write-through)
         this.addToCache(hash, data, metadata);
         // Update stats
@@ -169,17 +171,27 @@ export class BlobStorage {
             }
             this.stats.cacheMisses++;
         }
-        // Read from storage
-        const data = await this.adapter.get(`blob:${hash}`);
-        if (!data) {
-            throw new Error(`Blob not found: ${hash}`);
+        // Try to read metadata to determine type (for backward compatibility)
+        // Try commit, tree, then blob prefixes
+        let prefix = null;
+        let metadataBuffer;
+        let metadata;
+        for (const tryPrefix of ['commit', 'tree', 'blob']) {
+            metadataBuffer = await this.adapter.get(`${tryPrefix}-meta:${hash}`);
+            if (metadataBuffer) {
+                prefix = tryPrefix;
+                metadata = JSON.parse(metadataBuffer.toString());
+                break;
+            }
         }
-        // Read metadata
-        const metadataBuffer = await this.adapter.get(`blob-meta:${hash}`);
-        if (!metadataBuffer) {
+        if (!prefix || !metadata) {
             throw new Error(`Blob metadata not found: ${hash}`);
         }
-        const metadata = JSON.parse(metadataBuffer.toString());
+        // Read from storage using determined prefix
+        const data = await this.adapter.get(`${prefix}:${hash}`);
+        if (!data) {
+            throw new Error(`Blob not found: ${hash}`);
+        }
         // Decompress if needed
         let finalData = data;
         if (metadata.compression === 'zstd' && !options.skipDecompression) {
@@ -209,9 +221,14 @@ export class BlobStorage {
         if (this.cache.has(hash)) {
             return true;
         }
-        // Check storage
-        const exists = await this.adapter.get(`blob:${hash}`);
-        return exists !== undefined;
+        // Check storage - try all prefixes for backward compatibility
+        for (const prefix of ['commit', 'tree', 'blob']) {
+            const exists = await this.adapter.get(`${prefix}:${hash}`);
+            if (exists !== undefined) {
+                return true;
+            }
+        }
+        return false;
     }
     /**
      * Delete a blob from storage
@@ -230,10 +247,19 @@ export class BlobStorage {
         if (refCount > 0) {
             return;
         }
+        // Determine prefix by checking which one exists
+        let prefix = 'blob';
+        for (const tryPrefix of ['commit', 'tree', 'blob']) {
+            const exists = await this.adapter.get(`${tryPrefix}:${hash}`);
+            if (exists !== undefined) {
+                prefix = tryPrefix;
+                break;
+            }
+        }
         // Delete blob data
-        await this.adapter.delete(`blob:${hash}`);
+        await this.adapter.delete(`${prefix}:${hash}`);
         // Delete metadata
-        await this.adapter.delete(`blob-meta:${hash}`);
+        await this.adapter.delete(`${prefix}-meta:${hash}`);
         // Remove from cache
         this.removeFromCache(hash);
         // Update stats
@@ -246,11 +272,15 @@ export class BlobStorage {
      * @returns Blob metadata
      */
     async getMetadata(hash) {
-        const data = await this.adapter.get(`blob-meta:${hash}`);
-        if (!data) {
-            return undefined;
+        // Try to read metadata with type-aware prefix (backward compatible)
+        // Try commit, tree, then blob prefixes
+        for (const prefix of ['commit', 'tree', 'blob']) {
+            const data = await this.adapter.get(`${prefix}-meta:${hash}`);
+            if (data) {
+                return JSON.parse(data.toString());
+            }
         }
-        return JSON.parse(data.toString());
+        return undefined;
     }
     /**
      * Batch write multiple blobs in parallel
@@ -277,8 +307,16 @@ export class BlobStorage {
      * @returns Array of blob hashes
      */
     async listBlobs() {
-        const keys = await this.adapter.list('blob:');
-        return keys.map((key) => key.replace(/^blob:/, ''));
+        // List all types of blobs
+        const hashes = new Set();
+        for (const prefix of ['commit', 'tree', 'blob']) {
+            const keys = await this.adapter.list(`${prefix}:`);
+            keys.forEach((key) => {
+                const hash = key.replace(new RegExp(`^${prefix}:`), '');
+                hashes.add(hash);
+            });
+        }
+        return Array.from(hashes);
     }
     /**
      * Get storage statistics
@@ -349,7 +387,8 @@ export class BlobStorage {
     async writeMultipart(hash, data, metadata) {
         // For now, just write as single blob
         // TODO: Implement actual multipart upload for S3/R2/GCS
-        await this.adapter.put(`blob:${hash}`, data);
+        const prefix = metadata.type || 'blob';
+        await this.adapter.put(`${prefix}:${hash}`, data);
     }
     /**
      * Increment reference count for a blob
@@ -360,7 +399,8 @@ export class BlobStorage {
             throw new Error(`Cannot increment ref count, blob not found: ${hash}`);
         }
         metadata.refCount++;
-        await this.adapter.put(`blob-meta:${hash}`, Buffer.from(JSON.stringify(metadata)));
+        const prefix = metadata.type || 'blob';
+        await this.adapter.put(`${prefix}-meta:${hash}`, Buffer.from(JSON.stringify(metadata)));
         return metadata.refCount;
     }
     /**
@@ -372,7 +412,8 @@ export class BlobStorage {
             return 0;
         }
         metadata.refCount = Math.max(0, metadata.refCount - 1);
-        await this.adapter.put(`blob-meta:${hash}`, Buffer.from(JSON.stringify(metadata)));
+        const prefix = metadata.type || 'blob';
+        await this.adapter.put(`${prefix}-meta:${hash}`, Buffer.from(JSON.stringify(metadata)));
         return metadata.refCount;
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulcraft/brainy",
-  "version": "5.3.1",
+  "version": "5.3.3",
   "description": "Universal Knowledge Protocol™ - World's first Triple Intelligence database unifying vector, graph, and document search in one API. 31 nouns × 40 verbs for infinite expressiveness.",
   "main": "dist/index.js",
   "module": "dist/index.js",