@soulcraft/brainy 6.2.0 → 6.2.1

package/dist/types/brainyDataInterface.d.ts

@@ -0,0 +1,52 @@
+/**
+ * BrainyInterface - Modern API Only
+ *
+ * This interface defines the MODERN methods from Brainy 3.0.
+ * Used to break circular dependencies while enforcing modern API usage.
+ *
+ * NO DEPRECATED METHODS - Only clean, modern API patterns.
+ */
+import { Vector } from '../coreTypes.js';
+import { AddParams, RelateParams, Result, Entity, FindParams, SimilarParams } from './brainy.types.js';
+export interface BrainyInterface<T = unknown> {
+    /**
+     * Initialize the database
+     */
+    init(): Promise<void>;
+    /**
+     * Modern add method - unified entity creation
+     * @param params Parameters for adding entities
+     * @returns The ID of the created entity
+     */
+    add(params: AddParams<T>): Promise<string>;
+    /**
+     * Modern relate method - unified relationship creation
+     * @param params Parameters for creating relationships
+     * @returns The ID of the created relationship
+     */
+    relate(params: RelateParams<T>): Promise<string>;
+    /**
+     * Modern find method - unified search and discovery
+     * @param query Search query or parameters object
+     * @returns Array of search results
+     */
+    find(query: string | FindParams<T>): Promise<Result<T>[]>;
+    /**
+     * Modern get method - retrieve entities by ID
+     * @param id The entity ID to retrieve
+     * @returns Entity or null if not found
+     */
+    get(id: string): Promise<Entity<T> | null>;
+    /**
+     * Modern similar method - find similar entities
+     * @param params Parameters for similarity search
+     * @returns Array of similar entities with scores
+     */
+    similar(params: SimilarParams<T>): Promise<Result<T>[]>;
+    /**
+     * Generate embedding vector from text
+     * @param text The text to embed
+     * @returns Vector representation of the text
+     */
+    embed(text: string): Promise<Vector>;
+}

package/dist/types/brainyDataInterface.js

@@ -0,0 +1,10 @@
+/**
+ * BrainyInterface - Modern API Only
+ *
+ * This interface defines the MODERN methods from Brainy 3.0.
+ * Used to break circular dependencies while enforcing modern API usage.
+ *
+ * NO DEPRECATED METHODS - Only clean, modern API patterns.
+ */
+export {};
+//# sourceMappingURL=brainyDataInterface.js.map

package/dist/utils/metadataIndex.d.ts

@@ -436,6 +436,23 @@ export declare class MetadataIndexManager {
      * Get all entity types and their counts - O(1) operation
      */
     getAllEntityCounts(): Map<string, number>;
+    /**
+     * Get VFS entity count for a specific type using Roaring bitmap intersection
+     * Uses hardware-accelerated SIMD operations (AVX2/SSE4.2)
+     * @param type The noun type to query
+     * @returns Count of VFS entities of this type
+     */
+    getVFSEntityCountByType(type: string): Promise<number>;
+    /**
+     * Get all VFS entity counts by type using Roaring bitmap operations
+     * @returns Map of type -> VFS entity count
+     */
+    getAllVFSEntityCounts(): Promise<Map<string, number>>;
+    /**
+     * Get total count of VFS entities - O(1) using Roaring bitmap cardinality
+     * @returns Total VFS entity count
+     */
+    getTotalVFSEntityCount(): Promise<number>;
     /**
      * Get entity count for a noun type using type enum (O(1) array access)
      * More efficient than Map-based getEntityCountByType

package/dist/utils/metadataIndex.js

@@ -1230,6 +1230,21 @@ export class MetadataIndexManager {
                 const subIds = await this.getIdsForFilter(subFilter);
                 subIds.forEach(id => unionIds.add(id));
             }
+            // v6.2.1: Fix - Check for outer-level field conditions that need AND application
+            // This handles cases like { anyOf: [...], vfsType: { exists: false } }
+            // where the anyOf results must be intersected with other field conditions
+            const outerFields = Object.keys(filter).filter((k) => k !== 'anyOf' && k !== 'allOf' && k !== 'not');
+            if (outerFields.length > 0) {
+                // Build filter with just outer fields and get matching IDs
+                const outerFilter = {};
+                for (const field of outerFields) {
+                    outerFilter[field] = filter[field];
+                }
+                const outerIds = await this.getIdsForFilter(outerFilter);
+                const outerIdSet = new Set(outerIds);
+                // Intersect: anyOf union AND outer field conditions
+                return Array.from(unionIds).filter((id) => outerIdSet.has(id));
+            }
             return Array.from(unionIds);
         }
         // Process field filters with range support
@@ -1865,6 +1880,54 @@ export class MetadataIndexManager {
         return new Map(this.totalEntitiesByType);
     }
     // ============================================================================
+    // v6.2.1: VFS Statistics Methods (uses existing Roaring bitmap infrastructure)
+    // ============================================================================
+    /**
+     * Get VFS entity count for a specific type using Roaring bitmap intersection
+     * Uses hardware-accelerated SIMD operations (AVX2/SSE4.2)
+     * @param type The noun type to query
+     * @returns Count of VFS entities of this type
+     */
+    async getVFSEntityCountByType(type) {
+        const vfsBitmap = await this.getBitmapFromChunks('isVFSEntity', true);
+        const typeBitmap = await this.getBitmapFromChunks('noun', type);
+        if (!vfsBitmap || !typeBitmap)
+            return 0;
+        // Hardware-accelerated intersection + O(1) cardinality
+        const intersection = RoaringBitmap32.and(vfsBitmap, typeBitmap);
+        return intersection.size;
+    }
+    /**
+     * Get all VFS entity counts by type using Roaring bitmap operations
+     * @returns Map of type -> VFS entity count
+     */
+    async getAllVFSEntityCounts() {
+        const vfsBitmap = await this.getBitmapFromChunks('isVFSEntity', true);
+        if (!vfsBitmap || vfsBitmap.size === 0) {
+            return new Map();
+        }
+        const result = new Map();
+        // Iterate through all known types and compute VFS count via intersection
+        for (const type of this.totalEntitiesByType.keys()) {
+            const typeBitmap = await this.getBitmapFromChunks('noun', type);
+            if (typeBitmap) {
+                const intersection = RoaringBitmap32.and(vfsBitmap, typeBitmap);
+                if (intersection.size > 0) {
+                    result.set(type, intersection.size);
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Get total count of VFS entities - O(1) using Roaring bitmap cardinality
+     * @returns Total VFS entity count
+     */
+    async getTotalVFSEntityCount() {
+        const vfsBitmap = await this.getBitmapFromChunks('isVFSEntity', true);
+        return vfsBitmap?.size ?? 0;
+    }
+    // ============================================================================
     // Phase 1b: Type Enum Methods (O(1) access via Uint32Arrays)
     // ============================================================================
     /**

package/dist/vfs/ConceptSystem.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Universal Concept System for VFS
+ *
+ * Manages concepts that transcend files and exist independently
+ * Ideas that can be linked to multiple manifestations across domains
+ * PRODUCTION-READY: Real implementation using Brainy
+ */
+import { Brainy } from '../brainy.js';
+import { EntityManager, ManagedEntity } from './EntityManager.js';
+/**
+ * Universal concept that exists independently of files
+ */
+export interface UniversalConcept extends ManagedEntity {
+    id: string;
+    name: string;
+    description?: string;
+    domain: string;
+    category: string;
+    keywords: string[];
+    links: ConceptLink[];
+    manifestations: ConceptManifestation[];
+    strength: number;
+    created: number;
+    lastUpdated: number;
+    version: number;
+    metadata: Record<string, any>;
+    conceptType?: string;
+}
+/**
+ * A link between concepts
+ */
+export interface ConceptLink {
+    id: string;
+    targetConceptId: string;
+    relationship: 'extends' | 'implements' | 'uses' | 'opposite' | 'related' | 'contains' | 'part-of';
+    strength: number;
+    context?: string;
+    bidirectional: boolean;
+}
+/**
+ * A manifestation of a concept in a specific location
+ */
+export interface ConceptManifestation extends ManagedEntity {
+    id: string;
+    conceptId: string;
+    filePath: string;
+    context: string;
+    form: 'definition' | 'usage' | 'example' | 'discussion' | 'implementation';
+    position?: {
+        line?: number;
+        column?: number;
+        offset?: number;
+    };
+    confidence: number;
+    timestamp: number;
+    extractedBy: 'manual' | 'auto' | 'ai';
+}
+/**
+ * Configuration for concept system
+ */
+export interface ConceptSystemConfig {
+    autoLink?: boolean;
+    similarityThreshold?: number;
+    maxManifestations?: number;
+    strengthDecay?: number;
+}
+/**
+ * Concept graph structure for visualization
+ */
+export interface ConceptGraph {
+    concepts: Array<{
+        id: string;
+        name: string;
+        domain: string;
+        strength: number;
+        manifestationCount: number;
+    }>;
+    links: Array<{
+        source: string;
+        target: string;
+        relationship: string;
+        strength: number;
+    }>;
+}
+/**
+ * Universal Concept System
+ *
+ * Manages concepts that exist independently of any specific file or context
+ * Examples:
+ * - "Authentication" concept appearing in docs, code, tests
+ * - "Customer Journey" concept in marketing, UX, analytics
+ * - "Dependency Injection" pattern across multiple codebases
+ * - "Sustainability" theme in various research papers
+ */
+export declare class ConceptSystem extends EntityManager {
+    private config;
+    private conceptCache;
+    constructor(brain: Brainy, config?: ConceptSystemConfig);
+    /**
+     * Create a new universal concept
+     */
+    createConcept(concept: Omit<UniversalConcept, 'id' | 'created' | 'lastUpdated' | 'version' | 'links' | 'manifestations'>): Promise<string>;
+    /**
+     * Find concepts by various criteria
+     */
+    findConcepts(query: {
+        name?: string;
+        domain?: string;
+        category?: string;
+        keywords?: string[];
+        similar?: string;
+        manifestedIn?: string;
+    }): Promise<UniversalConcept[]>;
+    /**
+     * Link two concepts together
+     */
+    linkConcept(fromConceptId: string, toConceptId: string, relationship: ConceptLink['relationship'], options?: {
+        strength?: number;
+        context?: string;
+        bidirectional?: boolean;
+    }): Promise<string>;
+    /**
+     * Record a manifestation of a concept in a file
+     */
+    recordManifestation(conceptId: string, filePath: string, context: string, form: ConceptManifestation['form'], options?: {
+        position?: ConceptManifestation['position'];
+        confidence?: number;
+        extractedBy?: ConceptManifestation['extractedBy'];
+    }): Promise<string>;
+    /**
+     * Extract and link concepts from content
+     */
+    extractAndLinkConcepts(filePath: string, content: Buffer): Promise<string[]>;
+    /**
+     * Get concept graph for visualization
+     */
+    getConceptGraph(options?: {
+        domain?: string;
+        minStrength?: number;
+        maxConcepts?: number;
+    }): Promise<ConceptGraph>;
+    /**
+     * Find appearances of a concept
+     */
+    findAppearances(conceptId: string, options?: {
+        filePath?: string;
+        form?: ConceptManifestation['form'];
+        minConfidence?: number;
+        limit?: number;
+    }): Promise<ConceptManifestation[]>;
+    /**
+     * Auto-link concept to similar concepts
+     */
+    private autoLinkConcept;
+    /**
+     * Get concept by ID
+     */
+    private getConcept;
+    /**
+     * Update stored concept
+     */
+    private updateConcept;
+    /**
+     * Calculate similarity between two concepts
+     */
+    private calculateConceptSimilarity;
+    /**
+     * Generate embedding for concept
+     */
+    private generateConceptEmbedding;
+    /**
+     * Generate embedding for text
+     */
+    private generateTextEmbedding;
+    /**
+     * Get reverse relationship type
+     */
+    private getReverseRelationship;
+    /**
+     * Map concept relationship to VerbType
+     */
+    private getVerbType;
+    /**
+     * Detect concept domain from context
+     */
+    private detectDomain;
+    /**
+     * Detect concept category
+     */
+    private detectCategory;
+    /**
+     * Detect manifestation form from context
+     */
+    private detectManifestationForm;
+    /**
+     * Extract context around a position
+     */
+    private extractContext;
+    /**
+     * Clear concept cache
+     */
+    clearCache(conceptId?: string): void;
+}