@soulcraft/brainy 2.0.1 → 2.1.0

package/dist/importManager.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Import Manager - Comprehensive data import with intelligent type detection
+ *
+ * Handles multiple data sources:
+ * - Direct data (objects, arrays)
+ * - Files (JSON, CSV, text)
+ * - URLs (fetch and parse)
+ * - Streams (for large files)
+ *
+ * Uses NeuralImportAugmentation for intelligent processing
+ */
+import { NounType } from './types/graphTypes.js';
+export interface ImportOptions {
+    source?: 'data' | 'file' | 'url' | 'auto';
+    format?: 'json' | 'csv' | 'text' | 'yaml' | 'auto';
+    batchSize?: number;
+    autoDetect?: boolean;
+    typeHint?: NounType;
+    extractRelationships?: boolean;
+    csvDelimiter?: string;
+    csvHeaders?: boolean;
+    parallel?: boolean;
+    maxConcurrency?: number;
+}
+export interface ImportResult {
+    success: boolean;
+    nouns: string[];
+    verbs: string[];
+    errors: string[];
+    stats: {
+        total: number;
+        imported: number;
+        failed: number;
+        relationships: number;
+    };
+}
+export declare class ImportManager {
+    private neuralImport;
+    private typeMatcher;
+    private brain;
+    constructor(brain: any);
+    /**
+     * Initialize the import manager
+     */
+    init(): Promise<void>;
+    /**
+     * Main import method - handles all sources
+     */
+    import(source: string | Buffer | any[] | any, options?: ImportOptions): Promise<ImportResult>;
+    /**
+     * Import from file
+     */
+    importFile(filePath: string, options?: ImportOptions): Promise<ImportResult>;
+    /**
+     * Import from URL
+     */
+    importUrl(url: string, options?: ImportOptions): Promise<ImportResult>;
+    /**
+     * Detect source type
+     */
+    private detectSourceType;
+    /**
+     * Detect format from file path
+     */
+    private detectFormatFromPath;
+    /**
+     * Read file
+     */
+    private readFile;
+    /**
+     * Fetch from URL
+     */
+    private fetchFromUrl;
+}
+/**
+ * Create an import manager instance
+ */
+export declare function createImportManager(brain: any): ImportManager;

package/dist/importManager.js

@@ -0,0 +1,258 @@
+/**
+ * Import Manager - Comprehensive data import with intelligent type detection
+ *
+ * Handles multiple data sources:
+ * - Direct data (objects, arrays)
+ * - Files (JSON, CSV, text)
+ * - URLs (fetch and parse)
+ * - Streams (for large files)
+ *
+ * Uses NeuralImportAugmentation for intelligent processing
+ */
+import { VerbType } from './types/graphTypes.js';
+import { NeuralImportAugmentation } from './augmentations/neuralImport.js';
+import * as fs from './universal/fs.js';
+import * as path from './universal/path.js';
+import { prodLog } from './utils/logger.js';
+export class ImportManager {
+    constructor(brain) {
+        this.typeMatcher = null;
+        this.brain = brain;
+        this.neuralImport = new NeuralImportAugmentation();
+    }
+    /**
+     * Initialize the import manager
+     */
+    async init() {
+        // Initialize neural import with proper context
+        const context = {
+            brain: this.brain,
+            storage: this.brain.storage,
+            config: {},
+            log: (message, level) => {
+                if (level === 'error') {
+                    prodLog.error(message);
+                }
+                else if (level === 'warn') {
+                    prodLog.warn(message);
+                }
+                else {
+                    prodLog.info(message);
+                }
+            }
+        };
+        await this.neuralImport.initialize(context);
+        // Get type matcher
+        const { getTypeMatcher } = await import('./augmentations/typeMatching/intelligentTypeMatcher.js');
+        this.typeMatcher = await getTypeMatcher();
+    }
+    /**
+     * Main import method - handles all sources
+     */
+    async import(source, options = {}) {
+        const result = {
+            success: false,
+            nouns: [],
+            verbs: [],
+            errors: [],
+            stats: {
+                total: 0,
+                imported: 0,
+                failed: 0,
+                relationships: 0
+            }
+        };
+        try {
+            // Detect source type
+            const sourceType = await this.detectSourceType(source, options.source);
+            // Get data based on source type
+            let data;
+            let format = options.format || 'auto';
+            switch (sourceType) {
+                case 'url':
+                    data = await this.fetchFromUrl(source);
+                    break;
+                case 'file':
+                    const filePath = source;
+                    data = await this.readFile(filePath);
+                    if (format === 'auto') {
+                        format = this.detectFormatFromPath(filePath);
+                    }
+                    break;
+                case 'data':
+                default:
+                    data = source;
+                    break;
+            }
+            // Process data through neural import
+            let items;
+            let relationships = [];
+            if (Buffer.isBuffer(data) || typeof data === 'string') {
+                // Use neural import for parsing and analysis
+                const analysis = await this.neuralImport.getNeuralAnalysis(data, format);
+                // Extract items and relationships
+                items = analysis.detectedEntities.map(entity => ({
+                    data: entity.originalData,
+                    type: entity.nounType,
+                    confidence: entity.confidence,
+                    id: entity.suggestedId
+                }));
+                if (options.extractRelationships !== false) {
+                    relationships = analysis.detectedRelationships;
+                }
+                // Log insights
+                for (const insight of analysis.insights) {
+                    prodLog.info(`🧠 ${insight.description} (confidence: ${insight.confidence})`);
+                }
+            }
+            else if (Array.isArray(data)) {
+                items = data;
+            }
+            else {
+                items = [data];
+            }
+            result.stats.total = items.length;
+            // Import items in batches
+            const batchSize = options.batchSize || 50;
+            for (let i = 0; i < items.length; i += batchSize) {
+                const batch = items.slice(i, i + batchSize);
+                // Process batch in parallel if enabled
+                const promises = batch.map(async (item) => {
+                    try {
+                        // Detect type if needed
+                        let nounType = item.type || options.typeHint;
+                        if (!nounType && options.autoDetect !== false && this.typeMatcher) {
+                            const match = await this.typeMatcher.matchNounType(item.data || item);
+                            nounType = match.type;
+                        }
+                        // Prepare the data to import
+                        const dataToImport = item.data || item;
+                        // Create metadata combining original data with import metadata
+                        const metadata = {
+                            ...(typeof dataToImport === 'object' ? dataToImport : {}),
+                            ...(item.data?.metadata || {}),
+                            nounType,
+                            _importedAt: new Date().toISOString(),
+                            _confidence: item.confidence
+                        };
+                        // Add to brain - pass object once, it becomes both vector source and metadata
+                        const id = await this.brain.addNoun(metadata);
+                        result.nouns.push(id);
+                        result.stats.imported++;
+                        return id;
+                    }
+                    catch (error) {
+                        result.errors.push(`Failed to import item: ${error.message}`);
+                        result.stats.failed++;
+                        return null;
+                    }
+                });
+                if (options.parallel !== false) {
+                    await Promise.all(promises);
+                }
+                else {
+                    for (const promise of promises) {
+                        await promise;
+                    }
+                }
+            }
+            // Import relationships
+            for (const rel of relationships) {
+                try {
+                    // Match verb type if needed
+                    let verbType = rel.verbType;
+                    if (!Object.values(VerbType).includes(verbType) && this.typeMatcher) {
+                        const match = await this.typeMatcher.matchVerbType({ id: rel.sourceId }, { id: rel.targetId }, rel.verbType);
+                        verbType = match.type;
+                    }
+                    const verbId = await this.brain.addVerb(rel.sourceId, rel.targetId, verbType, rel.metadata, rel.weight);
+                    result.verbs.push(verbId);
+                    result.stats.relationships++;
+                }
+                catch (error) {
+                    result.errors.push(`Failed to create relationship: ${error.message}`);
+                }
+            }
+            result.success = result.stats.imported > 0;
+            prodLog.info(`✨ Import complete: ${result.stats.imported}/${result.stats.total} items, ${result.stats.relationships} relationships`);
+        }
+        catch (error) {
+            result.errors.push(`Import failed: ${error.message}`);
+            prodLog.error('Import failed:', error);
+        }
+        return result;
+    }
+    /**
+     * Import from file
+     */
+    async importFile(filePath, options = {}) {
+        return this.import(filePath, { ...options, source: 'file' });
+    }
+    /**
+     * Import from URL
+     */
+    async importUrl(url, options = {}) {
+        return this.import(url, { ...options, source: 'url' });
+    }
+    /**
+     * Detect source type
+     */
+    async detectSourceType(source, hint) {
+        if (hint && hint !== 'auto') {
+            return hint;
+        }
+        if (typeof source === 'string') {
+            // Check if URL
+            if (source.startsWith('http://') || source.startsWith('https://')) {
+                return 'url';
+            }
+            // Check if file path exists
+            try {
+                if (await fs.exists(source)) {
+                    return 'file';
+                }
+            }
+            catch { }
+        }
+        return 'data';
+    }
+    /**
+     * Detect format from file path
+     */
+    detectFormatFromPath(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        switch (ext) {
+            case '.json': return 'json';
+            case '.csv': return 'csv';
+            case '.txt': return 'text';
+            case '.md': return 'text';
+            case '.yaml':
+            case '.yml': return 'yaml';
+            default: return 'auto';
+        }
+    }
+    /**
+     * Read file
+     */
+    async readFile(filePath) {
+        const content = await fs.readFile(filePath, 'utf8');
+        return Buffer.from(content, 'utf8');
+    }
+    /**
+     * Fetch from URL
+     */
+    async fetchFromUrl(url) {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${url}: ${response.statusText}`);
+        }
+        return response.text();
+    }
+}
+/**
+ * Create an import manager instance
+ */
+export function createImportManager(brain) {
+    return new ImportManager(brain);
+}
+//# sourceMappingURL=importManager.js.map

package/dist/neural/embeddedPatterns.d.ts

@@ -2,7 +2,7 @@
  * 🧠 BRAINY EMBEDDED PATTERNS
  *
  * AUTO-GENERATED - DO NOT EDIT
- * Generated: 2025-08-26T19:59:35.203Z
+ * Generated: 2025-08-27T16:58:35.801Z
  * Patterns: 220
  * Coverage: 94-98% of all queries
  *

package/dist/neural/embeddedPatterns.js

@@ -2,7 +2,7 @@
  * 🧠 BRAINY EMBEDDED PATTERNS
  *
  * AUTO-GENERATED - DO NOT EDIT
- * Generated: 2025-08-26T19:59:35.203Z
+ * Generated: 2025-08-27T16:58:35.801Z
  * Patterns: 220
  * Coverage: 94-98% of all queries
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@soulcraft/brainy",
-  "version": "2.0.1",
-  "description": "Multi-Dimensional AI Database - Vector search, graph relationships, field filtering with Triple Intelligence Engine, HNSW indexing and universal storage",
+  "version": "2.1.0",
+  "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",
   "types": "dist/index.d.ts",
@@ -58,8 +58,10 @@
     "node": ">=18.0.0"
   },
   "scripts": {
-    "build": "npm run build:patterns && tsc",
+    "build": "npm run build:patterns:if-needed && tsc",
     "build:patterns": "tsx scripts/buildEmbeddedPatterns.ts",
+    "build:patterns:if-needed": "node scripts/check-patterns.cjs || npm run build:patterns",
+    "build:patterns:force": "npm run build:patterns",
     "prepare": "npm run build",
     "test": "npm run test:unit",
     "test:watch": "vitest --config tests/configs/vitest.unit.config.ts",