@soulcraft/brainy 2.0.2 → 2.3.0

package/dist/augmentations/storageAugmentation.d.ts

@@ -12,6 +12,7 @@ import { StorageAdapter } from '../coreTypes.js';
  */
 export declare abstract class StorageAugmentation extends BaseAugmentation implements BrainyAugmentation {
     readonly timing: "replace";
+    readonly metadata: "none";
     operations: ("storage")[];
     readonly priority = 100;
     protected storageAdapter: StorageAdapter | null;

package/dist/augmentations/storageAugmentation.js

@@ -14,6 +14,7 @@ export class StorageAugmentation extends BaseAugmentation {
     constructor() {
         super();
         this.timing = 'replace';
+        this.metadata = 'none'; // Storage doesn't directly access metadata
         this.operations = ['storage']; // Make mutable for TypeScript compatibility
         this.priority = 100; // High priority for storage
         this.storageAdapter = null;

package/dist/augmentations/synapseAugmentation.d.ts

@@ -27,6 +27,10 @@ export declare abstract class SynapseAugmentation extends BaseAugmentation {
     readonly timing: "after";
     readonly operations: ("all")[];
     readonly priority = 10;
+    readonly metadata: {
+        reads: "*";
+        writes: string[];
+    };
     abstract readonly synapseId: string;
     abstract readonly supportedTypes: string[];
     protected syncInProgress: boolean;

package/dist/augmentations/synapseAugmentation.js

@@ -29,6 +29,10 @@ export class SynapseAugmentation extends BaseAugmentation {
         this.timing = 'after';
         this.operations = ['all'];
         this.priority = 10;
+        this.metadata = {
+            reads: '*', // Needs to read for syncing
+            writes: ['_synapse', '_syncedAt']
+        }; // Adds synapse tracking metadata
         // State management
         this.syncInProgress = false;
         this.syncStats = {

package/dist/augmentations/typeMatching/intelligentTypeMatcher.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Intelligent Type Matcher - Uses embeddings for semantic type detection
+ *
+ * This module uses our existing TransformerEmbedding and similarity functions
+ * to intelligently match data to our 31 noun types and 40 verb types.
+ *
+ * Features:
+ * - Semantic similarity matching using embeddings
+ * - Context-aware type detection
+ * - Confidence scoring
+ * - Caching for performance
+ */
+/**
+ * Result of type matching with confidence scores
+ */
+export interface TypeMatchResult {
+    type: string;
+    confidence: number;
+    reasoning: string;
+    alternatives: Array<{
+        type: string;
+        confidence: number;
+    }>;
+}
+/**
+ * Intelligent Type Matcher using semantic embeddings
+ */
+export declare class IntelligentTypeMatcher {
+    private embedder;
+    private nounEmbeddings;
+    private verbEmbeddings;
+    private initialized;
+    private cache;
+    constructor();
+    /**
+     * Initialize the type matcher by generating embeddings for all types
+     */
+    init(): Promise<void>;
+    /**
+     * Match an object to the most appropriate noun type
+     */
+    matchNounType(obj: any): Promise<TypeMatchResult>;
+    /**
+     * Match a relationship to the most appropriate verb type
+     */
+    matchVerbType(sourceObj: any, targetObj: any, relationshipHint?: string): Promise<TypeMatchResult>;
+    /**
+     * Create text representation of an object for embedding
+     */
+    private createTextRepresentation;
+    /**
+     * Create text representation of a relationship
+     */
+    private createRelationshipText;
+    /**
+     * Get a brief summary of an object
+     */
+    private getObjectSummary;
+    /**
+     * Apply heuristic rules for noun type detection
+     */
+    private applyNounHeuristics;
+    /**
+     * Apply heuristic rules for verb type detection
+     */
+    private applyVerbHeuristics;
+    /**
+     * Generate human-readable reasoning for the type selection
+     */
+    private generateReasoning;
+    /**
+     * Clear the cache
+     */
+    clearCache(): void;
+    /**
+     * Dispose of resources
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * Get or create the global type matcher instance
+ */
+export declare function getTypeMatcher(): Promise<IntelligentTypeMatcher>;

package/dist/augmentations/typeMatching/intelligentTypeMatcher.js

@@ -0,0 +1,425 @@
+/**
+ * Intelligent Type Matcher - Uses embeddings for semantic type detection
+ *
+ * This module uses our existing TransformerEmbedding and similarity functions
+ * to intelligently match data to our 31 noun types and 40 verb types.
+ *
+ * Features:
+ * - Semantic similarity matching using embeddings
+ * - Context-aware type detection
+ * - Confidence scoring
+ * - Caching for performance
+ */
+import { NounType, VerbType } from '../../types/graphTypes.js';
+import { TransformerEmbedding } from '../../utils/embedding.js';
+import { cosineDistance } from '../../utils/distance.js';
+/**
+ * Type descriptions for semantic matching
+ * These descriptions are used to generate embeddings for each type
+ */
+const NOUN_TYPE_DESCRIPTIONS = {
+    // Core Entity Types
+    [NounType.Person]: 'person human individual user employee customer citizen member author creator agent actor participant',
+    [NounType.Organization]: 'organization company business corporation institution agency department team group committee board',
+    [NounType.Location]: 'location place address city country region area zone coordinate position site venue building',
+    [NounType.Thing]: 'thing object item product device equipment tool instrument asset artifact material physical tangible',
+    [NounType.Concept]: 'concept idea theory principle philosophy belief value abstract intangible notion thought',
+    [NounType.Event]: 'event occurrence incident activity happening meeting conference celebration milestone timestamp date',
+    // Digital/Content Types
+    [NounType.Document]: 'document file report article paper text pdf word contract agreement record documentation',
+    [NounType.Media]: 'media image photo video audio music podcast multimedia graphic visualization animation',
+    [NounType.File]: 'file digital data binary code script program software archive package bundle',
+    [NounType.Message]: 'message email chat communication notification alert announcement broadcast transmission',
+    [NounType.Content]: 'content information data text material resource publication post blog webpage',
+    // Collection Types
+    [NounType.Collection]: 'collection group set list array category folder directory catalog inventory database',
+    [NounType.Dataset]: 'dataset data table spreadsheet database records statistics metrics measurements analysis',
+    // Business/Application Types
+    [NounType.Product]: 'product item merchandise offering service feature application software solution package',
+    [NounType.Service]: 'service offering subscription support maintenance utility function capability',
+    [NounType.User]: 'user account profile member subscriber customer client participant identity credentials',
+    [NounType.Task]: 'task action todo item job assignment duty responsibility activity step procedure',
+    [NounType.Project]: 'project initiative program campaign effort endeavor plan scheme venture undertaking',
+    // Descriptive Types
+    [NounType.Process]: 'process workflow procedure method algorithm sequence pipeline operation routine protocol',
+    [NounType.State]: 'state status condition phase stage mode situation circumstance configuration setting',
+    [NounType.Role]: 'role position title function responsibility duty job capacity designation authority',
+    [NounType.Topic]: 'topic subject theme category tag keyword area domain field discipline specialty',
+    [NounType.Language]: 'language dialect locale tongue vernacular communication speech linguistics vocabulary',
+    [NounType.Currency]: 'currency money dollar euro pound yen bitcoin payment financial monetary unit',
+    [NounType.Measurement]: 'measurement metric quantity value amount size dimension weight height volume distance',
+    // Scientific/Research Types
+    [NounType.Hypothesis]: 'hypothesis theory proposition thesis assumption premise conjecture speculation prediction',
+    [NounType.Experiment]: 'experiment test trial study research investigation analysis observation examination',
+    // Legal/Regulatory Types
+    [NounType.Contract]: 'contract agreement deal treaty pact covenant license terms conditions policy',
+    [NounType.Regulation]: 'regulation law rule policy standard compliance requirement guideline ordinance statute',
+    // Technical Infrastructure Types
+    [NounType.Interface]: 'interface API endpoint protocol specification contract schema definition connection',
+    [NounType.Resource]: 'resource infrastructure server database storage compute memory bandwidth capacity asset'
+};
+const VERB_TYPE_DESCRIPTIONS = {
+    // Core Relationship Types
+    [VerbType.RelatedTo]: 'related connected associated linked correlated relevant pertinent applicable',
+    [VerbType.Contains]: 'contains includes holds stores encompasses comprises consists incorporates',
+    [VerbType.PartOf]: 'part component element member piece portion section segment constituent',
+    [VerbType.LocatedAt]: 'located situated positioned placed found exists resides occupies',
+    [VerbType.References]: 'references cites mentions points links refers quotes sources',
+    // Temporal/Causal Types
+    [VerbType.Precedes]: 'precedes before earlier prior previous antecedent preliminary foregoing',
+    [VerbType.Succeeds]: 'succeeds follows after later subsequent next ensuing succeeding',
+    [VerbType.Causes]: 'causes triggers induces produces generates results influences affects',
+    [VerbType.DependsOn]: 'depends requires needs relies necessitates contingent prerequisite',
+    [VerbType.Requires]: 'requires needs demands necessitates mandates obliges compels entails',
+    // Creation/Transformation Types
+    [VerbType.Creates]: 'creates makes produces generates builds constructs forms establishes',
+    [VerbType.Transforms]: 'transforms converts changes modifies alters transitions morphs evolves',
+    [VerbType.Becomes]: 'becomes turns evolves transforms changes transitions develops grows',
+    [VerbType.Modifies]: 'modifies changes updates alters edits revises adjusts adapts',
+    [VerbType.Consumes]: 'consumes uses utilizes depletes expends absorbs takes processes',
+    // Ownership/Attribution Types
+    [VerbType.Owns]: 'owns possesses holds controls manages administers governs maintains',
+    [VerbType.AttributedTo]: 'attributed credited assigned ascribed authored written composed',
+    [VerbType.CreatedBy]: 'created made produced generated built developed authored written',
+    [VerbType.BelongsTo]: 'belongs property possession part member affiliate associated owned',
+    // Social/Organizational Types
+    [VerbType.MemberOf]: 'member participant affiliate associate belongs joined enrolled registered',
+    [VerbType.WorksWith]: 'works collaborates cooperates partners teams assists helps supports',
+    [VerbType.FriendOf]: 'friend companion buddy pal acquaintance associate connection relationship',
+    [VerbType.Follows]: 'follows subscribes tracks monitors watches observes trails pursues',
+    [VerbType.Likes]: 'likes enjoys appreciates favors prefers admires values endorses',
+    [VerbType.ReportsTo]: 'reports answers subordinate accountable responsible supervised managed',
+    [VerbType.Supervises]: 'supervises manages oversees directs leads controls guides administers',
+    [VerbType.Mentors]: 'mentors teaches guides coaches instructs trains advises counsels',
+    [VerbType.Communicates]: 'communicates talks speaks messages contacts interacts corresponds exchanges',
+    // Descriptive/Functional Types
+    [VerbType.Describes]: 'describes explains details documents specifies outlines depicts characterizes',
+    [VerbType.Defines]: 'defines specifies establishes determines sets declares identifies designates',
+    [VerbType.Categorizes]: 'categorizes classifies groups sorts organizes arranges labels tags',
+    [VerbType.Measures]: 'measures quantifies gauges assesses evaluates calculates determines counts',
+    [VerbType.Evaluates]: 'evaluates assesses analyzes reviews examines appraises judges rates',
+    [VerbType.Uses]: 'uses utilizes employs applies operates handles manipulates exploits',
+    [VerbType.Implements]: 'implements executes realizes performs accomplishes carries delivers completes',
+    [VerbType.Extends]: 'extends expands enhances augments amplifies broadens enlarges develops',
+    // Enhanced Relationships
+    [VerbType.Inherits]: 'inherits derives extends receives obtains acquires succeeds legacy',
+    [VerbType.Conflicts]: 'conflicts contradicts opposes clashes disputes disagrees incompatible inconsistent',
+    [VerbType.Synchronizes]: 'synchronizes coordinates aligns harmonizes matches corresponds parallels coincides',
+    [VerbType.Competes]: 'competes rivals contends contests challenges opposes vies struggles'
+};
+/**
+ * Intelligent Type Matcher using semantic embeddings
+ */
+export class IntelligentTypeMatcher {
+    constructor() {
+        this.nounEmbeddings = new Map();
+        this.verbEmbeddings = new Map();
+        this.initialized = false;
+        this.cache = new Map();
+        this.embedder = new TransformerEmbedding({ verbose: false });
+    }
+    /**
+     * Initialize the type matcher by generating embeddings for all types
+     */
+    async init() {
+        if (this.initialized)
+            return;
+        await this.embedder.init();
+        // Generate embeddings for noun types
+        for (const [type, description] of Object.entries(NOUN_TYPE_DESCRIPTIONS)) {
+            const embedding = await this.embedder.embed(description);
+            this.nounEmbeddings.set(type, embedding);
+        }
+        // Generate embeddings for verb types
+        for (const [type, description] of Object.entries(VERB_TYPE_DESCRIPTIONS)) {
+            const embedding = await this.embedder.embed(description);
+            this.verbEmbeddings.set(type, embedding);
+        }
+        this.initialized = true;
+    }
+    /**
+     * Match an object to the most appropriate noun type
+     */
+    async matchNounType(obj) {
+        await this.init();
+        // Create a text representation of the object for embedding
+        const textRepresentation = this.createTextRepresentation(obj);
+        // Check cache
+        const cacheKey = `noun:${textRepresentation}`;
+        if (this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey);
+        }
+        // Generate embedding for the input
+        const inputEmbedding = await this.embedder.embed(textRepresentation);
+        // Calculate similarities to all noun types
+        const similarities = [];
+        for (const [type, typeEmbedding] of this.nounEmbeddings.entries()) {
+            // Convert cosine distance to similarity (1 - distance)
+            const similarity = 1 - cosineDistance(inputEmbedding, typeEmbedding);
+            similarities.push({ type, similarity });
+        }
+        // Sort by similarity (highest first)
+        similarities.sort((a, b) => b.similarity - a.similarity);
+        // Apply heuristic rules for common patterns
+        const heuristicType = this.applyNounHeuristics(obj);
+        if (heuristicType) {
+            // Boost the heuristic type's confidence
+            const heuristicIndex = similarities.findIndex(s => s.type === heuristicType);
+            if (heuristicIndex > 0) {
+                similarities[heuristicIndex].similarity *= 1.2; // 20% boost
+                similarities.sort((a, b) => b.similarity - a.similarity);
+            }
+        }
+        // Create result
+        const result = {
+            type: similarities[0].type,
+            confidence: similarities[0].similarity,
+            reasoning: this.generateReasoning(obj, similarities[0].type, 'noun'),
+            alternatives: similarities.slice(1, 4).map(s => ({
+                type: s.type,
+                confidence: s.similarity
+            }))
+        };
+        // Cache result
+        this.cache.set(cacheKey, result);
+        return result;
+    }
+    /**
+     * Match a relationship to the most appropriate verb type
+     */
+    async matchVerbType(sourceObj, targetObj, relationshipHint) {
+        await this.init();
+        // Create text representation of the relationship
+        const textRepresentation = this.createRelationshipText(sourceObj, targetObj, relationshipHint);
+        // Check cache
+        const cacheKey = `verb:${textRepresentation}`;
+        if (this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey);
+        }
+        // Generate embedding
+        const inputEmbedding = await this.embedder.embed(textRepresentation);
+        // Calculate similarities to all verb types
+        const similarities = [];
+        for (const [type, typeEmbedding] of this.verbEmbeddings.entries()) {
+            const similarity = 1 - cosineDistance(inputEmbedding, typeEmbedding);
+            similarities.push({ type, similarity });
+        }
+        // Sort by similarity
+        similarities.sort((a, b) => b.similarity - a.similarity);
+        // Apply heuristic rules
+        const heuristicType = this.applyVerbHeuristics(sourceObj, targetObj, relationshipHint);
+        if (heuristicType) {
+            const heuristicIndex = similarities.findIndex(s => s.type === heuristicType);
+            if (heuristicIndex > 0) {
+                similarities[heuristicIndex].similarity *= 1.2;
+                similarities.sort((a, b) => b.similarity - a.similarity);
+            }
+        }
+        // Create result
+        const result = {
+            type: similarities[0].type,
+            confidence: similarities[0].similarity,
+            reasoning: this.generateReasoning({ source: sourceObj, target: targetObj, hint: relationshipHint }, similarities[0].type, 'verb'),
+            alternatives: similarities.slice(1, 4).map(s => ({
+                type: s.type,
+                confidence: s.similarity
+            }))
+        };
+        // Cache result
+        this.cache.set(cacheKey, result);
+        return result;
+    }
+    /**
+     * Create text representation of an object for embedding
+     */
+    createTextRepresentation(obj) {
+        const parts = [];
+        // Add type if available
+        if (typeof obj === 'object' && obj !== null) {
+            // Add field names and values
+            for (const [key, value] of Object.entries(obj)) {
+                parts.push(key);
+                if (typeof value === 'string') {
+                    parts.push(value.slice(0, 100)); // Limit string length
+                }
+                else if (typeof value === 'number' || typeof value === 'boolean') {
+                    parts.push(String(value));
+                }
+            }
+            // Add special fields with higher weight
+            const importantFields = ['type', 'kind', 'category', 'class', 'name', 'title', 'description'];
+            for (const field of importantFields) {
+                if (obj[field]) {
+                    parts.push(String(obj[field]));
+                    parts.push(String(obj[field])); // Double weight for important fields
+                }
+            }
+        }
+        else if (typeof obj === 'string') {
+            parts.push(obj);
+        }
+        else {
+            parts.push(String(obj));
+        }
+        return parts.join(' ');
+    }
+    /**
+     * Create text representation of a relationship
+     */
+    createRelationshipText(sourceObj, targetObj, relationshipHint) {
+        const parts = [];
+        if (relationshipHint) {
+            parts.push(relationshipHint);
+            parts.push(relationshipHint); // Double weight for explicit hint
+        }
+        // Add source context
+        if (sourceObj) {
+            parts.push('source:');
+            parts.push(this.getObjectSummary(sourceObj));
+        }
+        // Add target context
+        if (targetObj) {
+            parts.push('target:');
+            parts.push(this.getObjectSummary(targetObj));
+        }
+        return parts.join(' ');
+    }
+    /**
+     * Get a brief summary of an object
+     */
+    getObjectSummary(obj) {
+        if (typeof obj === 'string')
+            return obj.slice(0, 50);
+        if (typeof obj !== 'object' || obj === null)
+            return String(obj);
+        const summary = [];
+        const fields = ['type', 'name', 'title', 'id', 'category', 'kind'];
+        for (const field of fields) {
+            if (obj[field]) {
+                summary.push(String(obj[field]));
+            }
+        }
+        return summary.join(' ').slice(0, 100);
+    }
+    /**
+     * Apply heuristic rules for noun type detection
+     */
+    applyNounHeuristics(obj) {
+        if (typeof obj !== 'object' || obj === null)
+            return null;
+        // Person heuristics
+        if (obj.email || obj.firstName || obj.lastName || obj.username || obj.age || obj.gender) {
+            return NounType.Person;
+        }
+        // Organization heuristics
+        if (obj.companyName || obj.organizationId || obj.employees || obj.industry) {
+            return NounType.Organization;
+        }
+        // Location heuristics
+        if (obj.latitude || obj.longitude || obj.address || obj.city || obj.country || obj.coordinates) {
+            return NounType.Location;
+        }
+        // Document heuristics
+        if (obj.content && (obj.title || obj.author) || obj.documentType || obj.pages) {
+            return NounType.Document;
+        }
+        // Event heuristics
+        if (obj.startTime || obj.endTime || obj.date || obj.eventType || obj.attendees) {
+            return NounType.Event;
+        }
+        // Product heuristics
+        if (obj.price || obj.sku || obj.inventory || obj.productId) {
+            return NounType.Product;
+        }
+        // Task heuristics
+        if (obj.status && (obj.assignee || obj.dueDate) || obj.priority || obj.completed !== undefined) {
+            return NounType.Task;
+        }
+        // Media heuristics
+        if (obj.url && (obj.url.match(/\.(jpg|jpeg|png|gif|mp4|mp3|wav)/i))) {
+            return NounType.Media;
+        }
+        // Dataset heuristics
+        if (Array.isArray(obj.data) || obj.rows || obj.columns || obj.schema) {
+            return NounType.Dataset;
+        }
+        return null;
+    }
+    /**
+     * Apply heuristic rules for verb type detection
+     */
+    applyVerbHeuristics(sourceObj, targetObj, relationshipHint) {
+        if (!relationshipHint)
+            return null;
+        const hint = relationshipHint.toLowerCase();
+        // Ownership patterns
+        if (hint.includes('own') || hint.includes('possess') || hint.includes('has')) {
+            return VerbType.Owns;
+        }
+        // Creation patterns
+        if (hint.includes('create') || hint.includes('made') || hint.includes('authored')) {
+            return VerbType.Creates;
+        }
+        // Containment patterns
+        if (hint.includes('contain') || hint.includes('include') || hint.includes('has')) {
+            return VerbType.Contains;
+        }
+        // Membership patterns
+        if (hint.includes('member') || hint.includes('belong') || hint.includes('part')) {
+            return VerbType.MemberOf;
+        }
+        // Reference patterns
+        if (hint.includes('refer') || hint.includes('cite') || hint.includes('link')) {
+            return VerbType.References;
+        }
+        // Dependency patterns
+        if (hint.includes('depend') || hint.includes('require') || hint.includes('need')) {
+            return VerbType.DependsOn;
+        }
+        return null;
+    }
+    /**
+     * Generate human-readable reasoning for the type selection
+     */
+    generateReasoning(obj, selectedType, typeKind) {
+        const descriptions = typeKind === 'noun' ? NOUN_TYPE_DESCRIPTIONS : VERB_TYPE_DESCRIPTIONS;
+        const typeDesc = descriptions[selectedType];
+        if (typeKind === 'noun') {
+            const fields = Object.keys(obj).slice(0, 3).join(', ');
+            return `Matched to ${selectedType} based on semantic similarity to "${typeDesc.split(' ').slice(0, 5).join(' ')}..." and object fields: ${fields}`;
+        }
+        else {
+            return `Matched to ${selectedType} based on semantic similarity to "${typeDesc.split(' ').slice(0, 5).join(' ')}..." and relationship context`;
+        }
+    }
+    /**
+     * Clear the cache
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Dispose of resources
+     */
+    async dispose() {
+        await this.embedder.dispose();
+        this.cache.clear();
+        this.nounEmbeddings.clear();
+        this.verbEmbeddings.clear();
+    }
+}
+/**
+ * Singleton instance for efficient reuse
+ */
+let globalMatcher = null;
+/**
+ * Get or create the global type matcher instance
+ */
+export async function getTypeMatcher() {
+    if (!globalMatcher) {
+        globalMatcher = new IntelligentTypeMatcher();
+        await globalMatcher.init();
+    }
+    return globalMatcher;
+}
+//# sourceMappingURL=intelligentTypeMatcher.js.map

package/dist/augmentations/walAugmentation.d.ts

@@ -24,6 +24,7 @@ interface WALConfig {
 export declare class WALAugmentation extends BaseAugmentation {
     name: string;
     timing: "around";
+    metadata: "readonly";
     operations: ("addNoun" | "addVerb" | "saveNoun" | "saveVerb" | "updateMetadata" | "delete" | "deleteVerb" | "clear")[];
     priority: number;
     private config;

package/dist/augmentations/walAugmentation.js

@@ -17,6 +17,7 @@ export class WALAugmentation extends BaseAugmentation {
         super();
         this.name = 'WAL';
         this.timing = 'around';
+        this.metadata = 'readonly'; // Reads metadata for logging/recovery
         this.operations = ['addNoun', 'addVerb', 'saveNoun', 'saveVerb', 'updateMetadata', 'delete', 'deleteVerb', 'clear'];
         this.priority = 100; // Critical system operation - highest priority
         this.operationCounter = 0;

package/dist/brainyData.d.ts

@@ -6,6 +6,7 @@ import { HNSWIndex } from './hnsw/hnswIndex.js';
 import { HNSWIndexOptimized, HNSWOptimizedConfig } from './hnsw/hnswIndexOptimized.js';
 import { DistanceFunction, GraphVerb, EmbeddingFunction, HNSWConfig, SearchResult, SearchCursor, PaginatedSearchResult, StorageAdapter, Vector, VectorDocument } from './coreTypes.js';
 import { MetadataIndexConfig } from './utils/metadataIndex.js';
+import { CleanupConfig } from './utils/periodicCleanup.js';
 import { NounType, VerbType } from './types/graphTypes.js';
 import { WebSocketConnection } from './types/augmentations.js';
 import { BrainyDataInterface } from './types/brainyDataInterface.js';
@@ -393,6 +394,12 @@ export interface BrainyDataConfig {
      * Default: false (enabled automatically for distributed setups)
      */
     health?: boolean;
+    /**
+     * Periodic cleanup configuration for old soft-deleted items
+     * Automatically removes soft-deleted items after a specified age to prevent memory buildup
+     * Default: enabled with 1 hour max age and 15 minute cleanup interval
+     */
+    cleanup?: Partial<CleanupConfig>;
 }
 export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
     hnswIndex: HNSWIndex | HNSWIndexOptimized;
@@ -424,7 +431,9 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
     private _neural?;
     private _tripleEngine?;
     private _nlpProcessor?;
+    private _importManager?;
     private cacheAutoConfigurator;
+    private periodicCleanup;
     private timeoutConfig;
     private retryConfig;
     private cacheConfig;
@@ -484,6 +493,11 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * Phase 3 of two-phase initialization
      */
     private initializeAugmentations;
+    /**
+     * Initialize periodic cleanup system for old soft-deleted items
+     * SAFETY-CRITICAL: Coordinates with both HNSW and metadata indexes
+     */
+    private initializePeriodicCleanup;
     private checkReadOnly;
     /**
      * Check if the database is frozen and throw an error if it is
@@ -1034,7 +1048,15 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
     deleteVerbs(ids: string[]): Promise<boolean[]>;
     deleteVerb(id: string, options?: {
         service?: string;
-        hard?: boolean;
+    }): Promise<boolean>;
+    /**
+     * Restore a soft-deleted verb (complement to consistent soft delete)
+     * @param id The verb ID to restore
+     * @param options Options for the restore operation
+     * @returns Promise<boolean> True if restored, false if not found or not deleted
+     */
+    restoreVerb(id: string, options?: {
+        service?: string;
     }): Promise<boolean>;
     /**
      * Get the number of vectors in the database
@@ -1490,11 +1512,10 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * @param options Import options including type hints and processing mode
      * @returns Array of created IDs
      */
-    import(data: any[] | any, options?: {
-        typeHint?: NounType;
-        autoDetect?: boolean;
+    import(source: any[] | any | string | Buffer, options?: {
+        format?: 'auto' | 'json' | 'csv' | 'yaml' | 'text';
         batchSize?: number;
-        process?: 'auto' | 'guided' | 'explicit' | 'literal';
+        relationships?: boolean;
     }): Promise<string[]>;
     /**
      * Add Noun - Explicit noun creation with strongly-typed NounType
@@ -1630,6 +1651,12 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * @returns Success boolean
      */
     deleteNoun(id: string): Promise<boolean>;
+    /**
+     * Restore a soft-deleted noun (complement to consistent soft delete)
+     * @param id The noun ID to restore
+     * @returns Promise<boolean> True if restored, false if not found or not deleted
+     */
+    restoreNoun(id: string): Promise<boolean>;
     /**
      * Delete multiple nouns by IDs
      * @param ids Array of noun IDs