@soulcraft/brainy 3.17.0 → 3.19.0

package/dist/mcp/conversationTools.js

@@ -0,0 +1,470 @@
+/**
+ * MCP Conversation Tools
+ *
+ * Exposes ConversationManager functionality through MCP for Claude Code integration.
+ * Provides 6 tools for infinite agent memory.
+ *
+ * REAL IMPLEMENTATION - Uses ConversationManager which uses real Brainy APIs
+ */
+import { v4 as uuidv4 } from '../universal/uuid.js';
+import { MCP_VERSION } from '../types/mcpTypes.js';
+import { ConversationManager } from '../conversation/conversationManager.js';
+/**
+ * MCP Conversation Toolset
+ *
+ * Provides conversation and context management tools for AI agents
+ */
+export class MCPConversationToolset {
+    /**
+     * Create MCP Conversation Toolset
+     * @param brain Brainy instance
+     */
+    constructor(brain) {
+        this.brain = brain;
+        this.initialized = false;
+        this.conversationManager = new ConversationManager(brain);
+    }
+    /**
+     * Initialize the toolset
+     */
+    async init() {
+        if (this.initialized) {
+            return;
+        }
+        await this.conversationManager.init();
+        this.initialized = true;
+    }
+    /**
+     * Handle MCP tool execution request
+     * @param request MCP tool execution request
+     * @returns MCP response
+     */
+    async handleRequest(request) {
+        if (!this.initialized) {
+            await this.init();
+        }
+        try {
+            const { toolName, parameters } = request;
+            // Route to appropriate tool handler
+            switch (toolName) {
+                case 'conversation_save_message':
+                    return await this.handleSaveMessage(request.requestId, parameters);
+                case 'conversation_get_context':
+                    return await this.handleGetContext(request.requestId, parameters);
+                case 'conversation_search':
+                    return await this.handleSearch(request.requestId, parameters);
+                case 'conversation_get_thread':
+                    return await this.handleGetThread(request.requestId, parameters);
+                case 'conversation_save_artifact':
+                    return await this.handleSaveArtifact(request.requestId, parameters);
+                case 'conversation_find_similar':
+                    return await this.handleFindSimilar(request.requestId, parameters);
+                default:
+                    return this.createErrorResponse(request.requestId, 'UNKNOWN_TOOL', `Unknown conversation tool: ${toolName}`);
+            }
+        }
+        catch (error) {
+            return this.createErrorResponse(request.requestId, 'INTERNAL_ERROR', error instanceof Error ? error.message : String(error));
+        }
+    }
+    /**
+     * Get available conversation tools
+     * @returns Array of MCP tool definitions
+     */
+    async getAvailableTools() {
+        return [
+            {
+                name: 'conversation_save_message',
+                description: 'Save a message to conversation history with automatic embedding and indexing',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        content: {
+                            type: 'string',
+                            description: 'Message content'
+                        },
+                        role: {
+                            type: 'string',
+                            enum: ['user', 'assistant', 'system', 'tool'],
+                            description: 'Message role'
+                        },
+                        conversationId: {
+                            type: 'string',
+                            description: 'Conversation ID (auto-generated if not provided)'
+                        },
+                        sessionId: {
+                            type: 'string',
+                            description: 'Session ID (optional)'
+                        },
+                        phase: {
+                            type: 'string',
+                            enum: [
+                                'understanding',
+                                'analysis',
+                                'planning',
+                                'implementation',
+                                'testing',
+                                'debugging',
+                                'refinement',
+                                'completed'
+                            ],
+                            description: 'Problem-solving phase'
+                        },
+                        confidence: {
+                            type: 'number',
+                            minimum: 0,
+                            maximum: 1,
+                            description: 'Confidence score (0-1)'
+                        },
+                        artifacts: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Artifact IDs or paths'
+                        },
+                        toolsUsed: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Names of tools used'
+                        },
+                        tags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Tags for categorization'
+                        },
+                        linkToPrevious: {
+                            type: 'string',
+                            description: 'ID of previous message to link'
+                        }
+                    },
+                    required: ['content', 'role']
+                }
+            },
+            {
+                name: 'conversation_get_context',
+                description: 'Retrieve relevant context from conversation history using semantic search',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'Query string for context retrieval'
+                        },
+                        conversationId: {
+                            type: 'string',
+                            description: 'Limit to specific conversation'
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum messages to return (default: 10)',
+                            default: 10
+                        },
+                        maxTokens: {
+                            type: 'number',
+                            description: 'Token budget for context (default: 50000)',
+                            default: 50000
+                        },
+                        relevanceThreshold: {
+                            type: 'number',
+                            minimum: 0,
+                            maximum: 1,
+                            description: 'Minimum similarity score (default: 0.7)',
+                            default: 0.7
+                        },
+                        role: {
+                            oneOf: [
+                                { type: 'string', enum: ['user', 'assistant', 'system', 'tool'] },
+                                { type: 'array', items: { type: 'string' } }
+                            ],
+                            description: 'Filter by message role'
+                        },
+                        tags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Filter by tags'
+                        },
+                        includeArtifacts: {
+                            type: 'boolean',
+                            description: 'Include linked artifacts',
+                            default: false
+                        },
+                        includeSimilarConversations: {
+                            type: 'boolean',
+                            description: 'Include similar past conversations',
+                            default: false
+                        }
+                    },
+                    required: ['query']
+                }
+            },
+            {
+                name: 'conversation_search',
+                description: 'Search messages semantically across all conversations',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'Search query'
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum results (default: 10)',
+                            default: 10
+                        },
+                        conversationId: {
+                            type: 'string',
+                            description: 'Limit to specific conversation'
+                        },
+                        role: {
+                            oneOf: [
+                                { type: 'string', enum: ['user', 'assistant', 'system', 'tool'] },
+                                { type: 'array', items: { type: 'string' } }
+                            ],
+                            description: 'Filter by role'
+                        },
+                        timeRange: {
+                            type: 'object',
+                            properties: {
+                                start: { type: 'number', description: 'Start timestamp' },
+                                end: { type: 'number', description: 'End timestamp' }
+                            },
+                            description: 'Time range filter'
+                        }
+                    },
+                    required: ['query']
+                }
+            },
+            {
+                name: 'conversation_get_thread',
+                description: 'Get full conversation thread with all messages',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        conversationId: {
+                            type: 'string',
+                            description: 'Conversation ID'
+                        },
+                        includeArtifacts: {
+                            type: 'boolean',
+                            description: 'Include linked artifacts',
+                            default: false
+                        }
+                    },
+                    required: ['conversationId']
+                }
+            },
+            {
+                name: 'conversation_save_artifact',
+                description: 'Save code/file artifact and link to conversation',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'VFS path for artifact'
+                        },
+                        content: {
+                            type: 'string',
+                            description: 'Artifact content'
+                        },
+                        conversationId: {
+                            type: 'string',
+                            description: 'Conversation ID'
+                        },
+                        messageId: {
+                            type: 'string',
+                            description: 'Message ID to link artifact to'
+                        },
+                        type: {
+                            type: 'string',
+                            enum: ['code', 'config', 'data', 'document', 'other'],
+                            description: 'Artifact type'
+                        },
+                        language: {
+                            type: 'string',
+                            description: 'Programming language (for code artifacts)'
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Artifact description'
+                        }
+                    },
+                    required: ['path', 'content', 'conversationId']
+                }
+            },
+            {
+                name: 'conversation_find_similar',
+                description: 'Find similar past conversations using semantic similarity',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        conversationId: {
+                            type: 'string',
+                            description: 'Conversation ID to find similar to'
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum results (default: 5)',
+                            default: 5
+                        },
+                        threshold: {
+                            type: 'number',
+                            minimum: 0,
+                            maximum: 1,
+                            description: 'Minimum similarity threshold (default: 0.7)',
+                            default: 0.7
+                        }
+                    },
+                    required: ['conversationId']
+                }
+            }
+        ];
+    }
+    /**
+     * Handle save_message tool
+     * REAL: Uses ConversationManager.saveMessage()
+     */
+    async handleSaveMessage(requestId, parameters) {
+        const { content, role, conversationId, sessionId, phase, confidence, artifacts, toolsUsed, tags, linkToPrevious } = parameters;
+        // Validate required parameters
+        if (!content || !role) {
+            return this.createErrorResponse(requestId, 'INVALID_PARAMETERS', 'Missing required parameters: content and role are required');
+        }
+        // Save message (REAL)
+        const messageId = await this.conversationManager.saveMessage(content, role, {
+            conversationId,
+            sessionId,
+            phase,
+            confidence,
+            artifacts,
+            toolsUsed,
+            tags,
+            linkToPrevious
+        });
+        return this.createSuccessResponse(requestId, {
+            messageId,
+            conversationId: conversationId || messageId.split('_')[0]
+        });
+    }
+    /**
+     * Handle get_context tool
+     * REAL: Uses ConversationManager.getRelevantContext()
+     */
+    async handleGetContext(requestId, parameters) {
+        const { query, ...options } = parameters;
+        if (!query) {
+            return this.createErrorResponse(requestId, 'INVALID_PARAMETERS', 'Missing required parameter: query');
+        }
+        // Get context (REAL)
+        const context = await this.conversationManager.getRelevantContext(query, options);
+        return this.createSuccessResponse(requestId, context);
+    }
+    /**
+     * Handle search tool
+     * REAL: Uses ConversationManager.searchMessages()
+     */
+    async handleSearch(requestId, parameters) {
+        const { query } = parameters;
+        if (!query) {
+            return this.createErrorResponse(requestId, 'INVALID_PARAMETERS', 'Missing required parameter: query');
+        }
+        // Search messages (REAL)
+        const results = await this.conversationManager.searchMessages(parameters);
+        return this.createSuccessResponse(requestId, {
+            results,
+            count: results.length
+        });
+    }
+    /**
+     * Handle get_thread tool
+     * REAL: Uses ConversationManager.getConversationThread()
+     */
+    async handleGetThread(requestId, parameters) {
+        const { conversationId, includeArtifacts = false } = parameters;
+        if (!conversationId) {
+            return this.createErrorResponse(requestId, 'INVALID_PARAMETERS', 'Missing required parameter: conversationId');
+        }
+        // Get thread (REAL)
+        const thread = await this.conversationManager.getConversationThread(conversationId, { includeArtifacts });
+        return this.createSuccessResponse(requestId, thread);
+    }
+    /**
+     * Handle save_artifact tool
+     * REAL: Uses ConversationManager.saveArtifact()
+     */
+    async handleSaveArtifact(requestId, parameters) {
+        const { path, content, conversationId, messageId, type, language, description } = parameters;
+        if (!path || !content || !conversationId) {
+            return this.createErrorResponse(requestId, 'INVALID_PARAMETERS', 'Missing required parameters: path, content, and conversationId are required');
+        }
+        // Save artifact (REAL)
+        const artifactId = await this.conversationManager.saveArtifact(path, content, {
+            conversationId,
+            messageId,
+            type,
+            language,
+            description
+        });
+        return this.createSuccessResponse(requestId, {
+            artifactId,
+            path
+        });
+    }
+    /**
+     * Handle find_similar tool
+     * REAL: Uses ConversationManager.findSimilarConversations()
+     */
+    async handleFindSimilar(requestId, parameters) {
+        const { conversationId, limit = 5, threshold = 0.7 } = parameters;
+        if (!conversationId) {
+            return this.createErrorResponse(requestId, 'INVALID_PARAMETERS', 'Missing required parameter: conversationId');
+        }
+        // Find similar (REAL)
+        const similar = await this.conversationManager.findSimilarConversations(conversationId, limit, threshold);
+        return this.createSuccessResponse(requestId, {
+            similar,
+            count: similar.length
+        });
+    }
+    /**
+     * Create success response
+     */
+    createSuccessResponse(requestId, data) {
+        return {
+            success: true,
+            requestId,
+            version: MCP_VERSION,
+            data
+        };
+    }
+    /**
+     * Create error response
+     */
+    createErrorResponse(requestId, code, message, details) {
+        return {
+            success: false,
+            requestId,
+            version: MCP_VERSION,
+            error: {
+                code,
+                message,
+                details
+            }
+        };
+    }
+    /**
+     * Generate request ID
+     */
+    generateRequestId() {
+        return uuidv4();
+    }
+}
+/**
+ * Create MCP conversation toolset
+ * @param brain Brainy instance
+ * @returns MCPConversationToolset instance
+ */
+export function createConversationToolset(brain) {
+    return new MCPConversationToolset(brain);
+}
+//# sourceMappingURL=conversationTools.js.map

package/dist/neural/embeddedPatterns.d.ts

@@ -2,7 +2,7 @@
  * 🧠 BRAINY EMBEDDED PATTERNS
  *
  * AUTO-GENERATED - DO NOT EDIT
- * Generated: 2025-09-15T16:41:42.483Z
+ * Generated: 2025-09-29T17:05:30.153Z
  * 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-09-15T16:41:42.483Z
+ * Generated: 2025-09-29T17:05:30.153Z
  * Patterns: 220
  * Coverage: 94-98% of all queries
  *

package/dist/neural/naturalLanguageProcessor.js

@@ -1015,7 +1015,6 @@ export class NaturalLanguageProcessor {
                         confidence
                     };
                     if (options?.includeMetadata) {
-                        ;
                         entity.metadata = {
                             pattern: pattern.source,
                             contextBefore: text.substring(Math.max(0, match.index - 20), match.index),

package/dist/setup.js

@@ -34,7 +34,6 @@ if (globalObj) {
         globalObj.TextDecoder = TextDecoder;
     }
     // Create special global constructors for library compatibility
-    ;
     globalObj.__TextEncoder__ = TextEncoder;
     globalObj.__TextDecoder__ = TextDecoder;
 }

package/dist/types/mcpTypes.d.ts

@@ -102,10 +102,16 @@ export interface MCPTool {
     parameters: {
         type: 'object';
         properties: Record<string, {
-            type: string;
+            type?: string;
             description: string;
             enum?: string[];
             required?: boolean;
+            minimum?: number;
+            maximum?: number;
+            default?: any;
+            items?: any;
+            oneOf?: any[];
+            [key: string]: any;
         }>;
         required: string[];
     };

package/dist/unified.js

@@ -41,7 +41,6 @@ export const environment = {
 };
 // Make environment information available globally
 if (typeof globalThis !== 'undefined') {
-    ;
     globalThis.__ENV__ = environment;
 }
 // Log the detected environment

package/dist/vfs/VirtualFileSystem.d.ts

@@ -19,6 +19,7 @@ import { IVirtualFileSystem, VFSConfig, VFSEntity, VFSMetadata, VFSStats, VFSDir
 export declare class VirtualFileSystem implements IVirtualFileSystem {
     private brain;
     private pathResolver;
+    private projectionRegistry;
     private config;
     private rootEntityId?;
     private initialized;
@@ -35,6 +36,11 @@ export declare class VirtualFileSystem implements IVirtualFileSystem {
     /**
      * Create or find the root directory entity
      */
+    /**
+     * Auto-register built-in projection strategies
+     * Zero-config: All semantic dimensions work out of the box
+     */
+    private registerBuiltInProjections;
     private initializeRoot;
     /**
      * Read a file's content
@@ -183,10 +189,6 @@ export declare class VirtualFileSystem implements IVirtualFileSystem {
      * Merges with existing metadata
      */
     setMetadata(path: string, metadata: Partial<VFSMetadata>): Promise<void>;
-    /**
-     * Enable Knowledge Layer on this VFS instance
-     */
-    enableKnowledgeLayer(): Promise<void>;
     /**
      * Set the current user for tracking who makes changes
      */

package/dist/vfs/VirtualFileSystem.js

@@ -7,8 +7,8 @@
 import crypto from 'crypto';
 import { Brainy } from '../brainy.js';
 import { NounType, VerbType } from '../types/graphTypes.js';
-import { PathResolver } from './PathResolver.js';
-// Knowledge Layer imports removed - now in KnowledgeAugmentation
+import { SemanticPathResolver, ProjectionRegistry, ConceptProjection, AuthorProjection, TemporalProjection, RelationshipProjection, SimilarityProjection, TagProjection } from './semantic/index.js';
+// Knowledge Layer can remain as optional augmentation for now
 import { VFSError, VFSErrorCode } from './types.js';
 /**
  * Main Virtual Filesystem Implementation
@@ -46,12 +46,12 @@ export class VirtualFileSystem {
         }
         // Create or find root entity
         this.rootEntityId = await this.initializeRoot();
-        // Initialize path resolver
-        this.pathResolver = new PathResolver(this.brain, this.rootEntityId, {
-            maxCacheSize: this.config.cache?.maxPaths,
-            cacheTTL: this.config.cache?.ttl,
-            hotPathThreshold: 10
-        });
+        // Initialize projection registry with auto-discovery of built-in projections
+        this.projectionRegistry = new ProjectionRegistry();
+        this.registerBuiltInProjections();
+        // Initialize semantic path resolver (zero-config, uses brain.config)
+        this.pathResolver = new SemanticPathResolver(this.brain, this, // Pass VFS instance for resolvePath
+        this.rootEntityId, this.projectionRegistry);
         // Knowledge Layer is now a separate augmentation
         // Enable with: brain.use('knowledge')
         // Start background tasks
@@ -61,6 +61,31 @@ export class VirtualFileSystem {
     /**
      * Create or find the root directory entity
      */
+    /**
+     * Auto-register built-in projection strategies
+     * Zero-config: All semantic dimensions work out of the box
+     */
+    registerBuiltInProjections() {
+        const projections = [
+            ConceptProjection,
+            AuthorProjection,
+            TemporalProjection,
+            RelationshipProjection,
+            SimilarityProjection,
+            TagProjection
+        ];
+        for (const ProjectionClass of projections) {
+            try {
+                this.projectionRegistry.register(new ProjectionClass());
+            }
+            catch (err) {
+                // Silently skip if already registered (e.g., in tests)
+                if (!(err instanceof Error && err.message.includes('already registered'))) {
+                    throw err;
+                }
+            }
+        }
+    }
     async initializeRoot() {
         // Check if root already exists - search using where clause
         const existing = await this.brain.find({
@@ -1026,6 +1051,17 @@ export class VirtualFileSystem {
             metadata.lineCount = text.split('\n').length;
             metadata.wordCount = text.split(/\s+/).filter(w => w).length;
             metadata.charset = 'utf-8';
+            // Extract concepts using brain.extractConcepts() (neural extraction)
+            if (this.config.intelligence?.autoConcepts) {
+                try {
+                    const concepts = await this.brain.extractConcepts(text, { limit: 20 });
+                    metadata.conceptNames = concepts; // Flattened for O(log n) queries
+                }
+                catch (error) {
+                    // Concept extraction is optional - don't fail if it errors
+                    console.debug('Concept extraction failed:', error);
+                }
+            }
         }
         // Extract hash for integrity
         const crypto = await import('crypto');
@@ -1193,9 +1229,6 @@ export class VirtualFileSystem {
                 maxFileSize: 1000000000, // 1GB
                 maxPathLength: 4096,
                 maxDirectoryEntries: 100000
-            },
-            knowledgeLayer: {
-                enabled: false // Default to disabled
             }
         };
     }
@@ -1732,16 +1765,6 @@ export class VirtualFileSystem {
         // Invalidate caches
         this.invalidateCaches(path);
     }
-    // ============= Knowledge Layer =============
-    // Knowledge Layer methods are added by KnowledgeLayer.enable()
-    // This keeps VFS pure and fast while allowing optional intelligence
-    /**
-     * Enable Knowledge Layer on this VFS instance
-     */
-    async enableKnowledgeLayer() {
-        const { enableKnowledgeLayer } = await import('./KnowledgeLayer.js');
-        await enableKnowledgeLayer(this, this.brain);
-    }
     /**
      * Set the current user for tracking who makes changes
      */

package/dist/vfs/index.d.ts

@@ -11,9 +11,4 @@ export { FSCompat, createFS } from './FSCompat.js';
 export { DirectoryImporter } from './importers/DirectoryImporter.js';
 export { VFSReadStream } from './streams/VFSReadStream.js';
 export { VFSWriteStream } from './streams/VFSWriteStream.js';
-export { EventRecorder } from './EventRecorder.js';
-export { SemanticVersioning } from './SemanticVersioning.js';
-export { PersistentEntitySystem } from './PersistentEntitySystem.js';
-export { ConceptSystem } from './ConceptSystem.js';
-export { GitBridge } from './GitBridge.js';
 export { VirtualFileSystem as VFS } from './VirtualFileSystem.js';