@soulcraft/brainy 3.18.0 → 3.19.1

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/types.d.ts

@@ -267,8 +267,8 @@ export interface StreamingBatch<T = SemanticCluster> {
 }
 export declare class NeuralAPIError extends Error {
     code: string;
-    context?: Record<string, any> | undefined;
-    constructor(message: string, code: string, context?: Record<string, any> | undefined);
+    context?: Record<string, any>;
+    constructor(message: string, code: string, context?: Record<string, any>);
 }
 export declare class ClusteringError extends NeuralAPIError {
     constructor(message: string, context?: Record<string, any>);

package/dist/streaming/pipeline.d.ts

@@ -43,7 +43,7 @@ export declare class Pipeline<T = any> {
     private running;
     private abortController?;
     private metrics;
-    constructor(brainyInstance?: (Brainy | Brainy<any>) | undefined);
+    constructor(brainyInstance?: Brainy | Brainy<any>);
     /**
      * Add a data source
      */

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/universal/fs.d.ts

@@ -28,74 +28,32 @@ export interface UniversalFS {
     }>;
     access(path: string, mode?: number): Promise<void>;
 }
-export declare const readFile: (path: string, encoding?: string) => Promise<string>;
-export declare const writeFile: (path: string, data: string, encoding?: string) => Promise<void>;
-export declare const mkdir: (path: string, options?: {
-    recursive?: boolean;
-}) => Promise<void>;
-export declare const exists: (path: string) => Promise<boolean>;
-export declare const readdir: {
-    (path: string): Promise<string[]>;
-    (path: string, options: {
-        withFileTypes: true;
-    }): Promise<{
-        name: string;
-        isDirectory(): boolean;
-        isFile(): boolean;
-    }[]>;
-};
-export declare const unlink: (path: string) => Promise<void>;
-export declare const stat: (path: string) => Promise<{
-    isFile(): boolean;
-    isDirectory(): boolean;
-}>;
-export declare const access: (path: string, mode?: number) => Promise<void>;
+export declare const readFile: any;
+export declare const writeFile: any;
+export declare const mkdir: any;
+export declare const exists: any;
+export declare const readdir: any;
+export declare const unlink: any;
+export declare const stat: any;
+export declare const access: any;
 declare const _default: {
-    readFile: (path: string, encoding?: string) => Promise<string>;
-    writeFile: (path: string, data: string, encoding?: string) => Promise<void>;
-    mkdir: (path: string, options?: {
-        recursive?: boolean;
-    }) => Promise<void>;
-    exists: (path: string) => Promise<boolean>;
-    readdir: {
-        (path: string): Promise<string[]>;
-        (path: string, options: {
-            withFileTypes: true;
-        }): Promise<{
-            name: string;
-            isDirectory(): boolean;
-            isFile(): boolean;
-        }[]>;
-    };
-    unlink: (path: string) => Promise<void>;
-    stat: (path: string) => Promise<{
-        isFile(): boolean;
-        isDirectory(): boolean;
-    }>;
-    access: (path: string, mode?: number) => Promise<void>;
+    readFile: any;
+    writeFile: any;
+    mkdir: any;
+    exists: any;
+    readdir: any;
+    unlink: any;
+    stat: any;
+    access: any;
 };
 export default _default;
 export declare const promises: {
-    readFile: (path: string, encoding?: string) => Promise<string>;
-    writeFile: (path: string, data: string, encoding?: string) => Promise<void>;
-    mkdir: (path: string, options?: {
-        recursive?: boolean;
-    }) => Promise<void>;
-    exists: (path: string) => Promise<boolean>;
-    readdir: {
-        (path: string): Promise<string[]>;
-        (path: string, options: {
-            withFileTypes: true;
-        }): Promise<{
-            name: string;
-            isDirectory(): boolean;
-            isFile(): boolean;
-        }[]>;
-    };
-    unlink: (path: string) => Promise<void>;
-    stat: (path: string) => Promise<{
-        isFile(): boolean;
-        isDirectory(): boolean;
-    }>;
-    access: (path: string, mode?: number) => Promise<void>;
+    readFile: any;
+    writeFile: any;
+    mkdir: any;
+    exists: any;
+    readdir: any;
+    unlink: any;
+    stat: any;
+    access: any;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulcraft/brainy",
-  "version": "3.18.0",
+  "version": "3.19.1",
   "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",
@@ -55,7 +55,7 @@
     "node": "22.x"
   },
   "scripts": {
-    "build": "npm run build:patterns:if-needed && tsc",
+    "build": "npm run build:patterns:if-needed && tsc && tsc -p tsconfig.cli.json",
     "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",