@soulcraft/brainy 3.18.0 → 3.19.1

package/dist/conversation/types.d.ts

@@ -0,0 +1,231 @@
+/**
+ * Conversation Types for Infinite Agent Memory
+ *
+ * Production-ready type definitions for storing and retrieving
+ * conversation history with semantic search and context management.
+ */
+/**
+ * Role of the message sender
+ */
+export type MessageRole = 'user' | 'assistant' | 'system' | 'tool';
+/**
+ * Problem-solving phase for tracking agent's progress
+ */
+export type ProblemSolvingPhase = 'understanding' | 'analysis' | 'planning' | 'implementation' | 'testing' | 'debugging' | 'refinement' | 'completed';
+/**
+ * Metadata for a conversation message
+ */
+export interface ConversationMessageMetadata {
+    role: MessageRole;
+    conversationId: string;
+    sessionId?: string;
+    timestamp: number;
+    problemSolvingPhase?: ProblemSolvingPhase;
+    confidence?: number;
+    tokensUsed?: number;
+    tokensTotal?: number;
+    artifacts?: string[];
+    toolsUsed?: string[];
+    references?: string[];
+    tags?: string[];
+    priority?: number;
+    archived?: boolean;
+    [key: string]: any;
+}
+/**
+ * A conversation message with all metadata
+ */
+export interface ConversationMessage {
+    id: string;
+    content: string;
+    role: MessageRole;
+    metadata: ConversationMessageMetadata;
+    embedding?: number[];
+    createdAt: number;
+    updatedAt: number;
+}
+/**
+ * Conversation thread metadata
+ */
+export interface ConversationThreadMetadata {
+    conversationId: string;
+    sessionId?: string;
+    title?: string;
+    summary?: string;
+    startTime: number;
+    endTime?: number;
+    messageCount: number;
+    totalTokens: number;
+    participants: string[];
+    tags?: string[];
+    archived?: boolean;
+    [key: string]: any;
+}
+/**
+ * A conversation thread (collection of messages)
+ */
+export interface ConversationThread {
+    id: string;
+    metadata: ConversationThreadMetadata;
+    messages: ConversationMessage[];
+    artifacts?: string[];
+}
+/**
+ * Options for retrieving relevant context
+ */
+export interface ContextRetrievalOptions {
+    query?: string;
+    conversationId?: string;
+    sessionId?: string;
+    role?: MessageRole | MessageRole[];
+    phase?: ProblemSolvingPhase | ProblemSolvingPhase[];
+    tags?: string[];
+    minConfidence?: number;
+    timeRange?: {
+        start?: number;
+        end?: number;
+    };
+    limit?: number;
+    maxTokens?: number;
+    relevanceThreshold?: number;
+    weights?: {
+        semantic?: number;
+        temporal?: number;
+        graph?: number;
+    };
+    includeArtifacts?: boolean;
+    includeSimilarConversations?: boolean;
+    deduplicateClusters?: boolean;
+}
+/**
+ * Ranked context message with relevance score
+ */
+export interface RankedMessage extends ConversationMessage {
+    relevanceScore: number;
+    semanticScore?: number;
+    temporalScore?: number;
+    graphScore?: number;
+    explanation?: string;
+}
+/**
+ * Retrieved context result
+ */
+export interface ConversationContext {
+    messages: RankedMessage[];
+    artifacts?: Array<{
+        path: string;
+        id: string;
+        content?: string;
+        summary?: string;
+    }>;
+    similarConversations?: Array<{
+        id: string;
+        title?: string;
+        summary?: string;
+        relevance: number;
+        messageCount: number;
+    }>;
+    totalTokens: number;
+    metadata: {
+        queryTime: number;
+        messagesConsidered: number;
+        conversationsSearched: number;
+    };
+}
+/**
+ * Options for saving messages
+ */
+export interface SaveMessageOptions {
+    conversationId?: string;
+    sessionId?: string;
+    phase?: ProblemSolvingPhase;
+    confidence?: number;
+    artifacts?: string[];
+    toolsUsed?: string[];
+    tags?: string[];
+    linkToPrevious?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Options for conversation search
+ */
+export interface ConversationSearchOptions {
+    query: string;
+    limit?: number;
+    role?: MessageRole | MessageRole[];
+    conversationId?: string;
+    sessionId?: string;
+    timeRange?: {
+        start?: number;
+        end?: number;
+    };
+    includeMetadata?: boolean;
+    includeContent?: boolean;
+}
+/**
+ * Search result for conversations
+ */
+export interface ConversationSearchResult {
+    message: ConversationMessage;
+    score: number;
+    conversationId: string;
+    snippet?: string;
+}
+/**
+ * Theme discovered via clustering
+ */
+export interface ConversationTheme {
+    id: string;
+    label: string;
+    messages: string[];
+    centroid: number[];
+    coherence: number;
+    keywords?: string[];
+}
+/**
+ * Options for artifact storage
+ */
+export interface ArtifactOptions {
+    conversationId: string;
+    messageId?: string;
+    type?: 'code' | 'config' | 'data' | 'document' | 'other';
+    language?: string;
+    description?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Statistics about conversations
+ */
+export interface ConversationStats {
+    totalConversations: number;
+    totalMessages: number;
+    totalTokens: number;
+    averageMessagesPerConversation: number;
+    averageTokensPerMessage: number;
+    oldestMessage: number;
+    newestMessage: number;
+    phases: Record<ProblemSolvingPhase, number>;
+    roles: Record<MessageRole, number>;
+}
+/**
+ * Compaction strategy options
+ */
+export interface CompactionOptions {
+    conversationId: string;
+    strategy?: 'cluster-based' | 'importance-based' | 'hybrid';
+    keepRatio?: number;
+    minImportance?: number;
+    preservePhases?: ProblemSolvingPhase[];
+    preserveRecent?: number;
+}
+/**
+ * Result of compaction operation
+ */
+export interface CompactionResult {
+    originalCount: number;
+    compactedCount: number;
+    removedCount: number;
+    tokensFreed: number;
+    preservedMessageIds: string[];
+    summaryMessageId?: string;
+}

package/dist/conversation/types.js

@@ -0,0 +1,8 @@
+/**
+ * Conversation Types for Infinite Agent Memory
+ *
+ * Production-ready type definitions for storing and retrieving
+ * conversation history with semantic search and context management.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/hnsw/hnswIndexOptimized.d.ts

@@ -96,7 +96,7 @@ export declare class HNSWIndexOptimized extends HNSWIndex {
     private vectorCount;
     private memoryUpdateLock;
     private unifiedCache;
-    constructor(config: Partial<HNSWOptimizedConfig> | undefined, distanceFunction: DistanceFunction, storage?: StorageAdapter | null);
+    constructor(config: Partial<HNSWOptimizedConfig>, distanceFunction: DistanceFunction, storage?: StorageAdapter | null);
     /**
      * Thread-safe method to update memory usage
      * @param memoryDelta Change in memory usage (can be negative)

package/dist/index.d.ts

@@ -56,3 +56,6 @@ import { BrainyMCPAdapter, MCPAugmentationToolset, BrainyMCPService } from './mc
 import { MCPRequest, MCPResponse, MCPDataAccessRequest, MCPToolExecutionRequest, MCPSystemInfoRequest, MCPAuthenticationRequest, MCPRequestType, MCPServiceOptions, MCPTool, MCP_VERSION } from './types/mcpTypes.js';
 export { BrainyMCPAdapter, MCPAugmentationToolset, BrainyMCPService, MCPRequestType, MCP_VERSION };
 export type { MCPRequest, MCPResponse, MCPDataAccessRequest, MCPToolExecutionRequest, MCPSystemInfoRequest, MCPAuthenticationRequest, MCPServiceOptions, MCPTool };
+export { ConversationManager, createConversationManager } from './conversation/index.js';
+export { MCPConversationToolset, createConversationToolset } from './mcp/conversationTools.js';
+export type { MessageRole, ProblemSolvingPhase, ConversationMessage, ConversationMessageMetadata, ConversationThread, ConversationThreadMetadata, ConversationContext, RankedMessage, SaveMessageOptions, ContextRetrievalOptions, ConversationSearchOptions, ConversationSearchResult, ConversationTheme, ArtifactOptions, ConversationStats, CompactionOptions, CompactionResult } from './conversation/types.js';

package/dist/index.js

@@ -118,4 +118,7 @@ export {
 BrainyMCPAdapter, MCPAugmentationToolset, BrainyMCPService, 
 // MCP types
 MCPRequestType, MCP_VERSION };
+// Export Conversation API (Infinite Agent Memory)
+export { ConversationManager, createConversationManager } from './conversation/index.js';
+export { MCPConversationToolset, createConversationToolset } from './mcp/conversationTools.js';
 //# sourceMappingURL=index.js.map

package/dist/mcp/brainyMCPBroadcast.d.ts

@@ -11,7 +11,7 @@
  * - Works both locally and with cloud deployment
  */
 import { BrainyMCPService } from './brainyMCPService.js';
-import { BrainyDataInterface } from '../types/brainyDataInterface.js';
+import { BrainyInterface } from '../types/brainyDataInterface.js';
 import { MCPServiceOptions } from '../types/mcpTypes.js';
 interface BroadcastMessage {
     id: string;
@@ -28,7 +28,7 @@ export declare class BrainyMCPBroadcast extends BrainyMCPService {
     private agents;
     private messageHistory;
     private maxHistorySize;
-    constructor(brainyData: BrainyDataInterface, options?: MCPServiceOptions & {
+    constructor(brainyData: BrainyInterface, options?: MCPServiceOptions & {
         broadcastPort?: number;
         cloudUrl?: string;
     });

package/dist/mcp/brainyMCPBroadcast.js

@@ -11,7 +11,7 @@
  * - Works both locally and with cloud deployment
  */
 import { WebSocketServer, WebSocket } from 'ws';
-import { createServer } from 'http';
+import { createServer } from 'node:http';
 import { BrainyMCPService } from './brainyMCPService.js';
 import { v4 as uuidv4 } from '../universal/uuid.js';
 export class BrainyMCPBroadcast extends BrainyMCPService {

package/dist/mcp/brainyMCPClient.js

@@ -5,7 +5,7 @@
  * Utilizes Brainy for persistent memory and vector search capabilities
  */
 import WebSocket from 'ws';
-import { BrainyData } from '../brainyData.js';
+import { Brainy } from '../brainy.js';
 import { v4 as uuidv4 } from '../universal/uuid.js';
 export class BrainyMCPClient {
     constructor(options) {
@@ -23,7 +23,7 @@ export class BrainyMCPClient {
      */
     async initBrainy() {
         if (this.options.useBrainyMemory && !this.brainy) {
-            this.brainy = new BrainyData({
+            this.brainy = new Brainy({
                 storage: {
                     requestPersistentStorage: true
                 }
@@ -95,7 +95,8 @@ export class BrainyMCPClient {
                         to: message.to,
                         timestamp: message.timestamp,
                         type: message.type,
-                        event: message.event
+                        event: message.event,
+                        category: 'Message'
                     }
                 });
             }
@@ -111,7 +112,10 @@ export class BrainyMCPClient {
                 for (const histMsg of message.data.history) {
                     await this.brainy.add({
                         text: `${histMsg.from}: ${JSON.stringify(histMsg.data)}`,
-                        metadata: histMsg
+                        metadata: {
+                            ...histMsg,
+                            category: 'Message'
+                        }
                     });
                 }
             }

package/dist/mcp/conversationTools.d.ts

@@ -0,0 +1,88 @@
+/**
+ * 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 { MCPResponse, MCPToolExecutionRequest, MCPTool } from '../types/mcpTypes.js';
+import { Brainy } from '../brainy.js';
+/**
+ * MCP Conversation Toolset
+ *
+ * Provides conversation and context management tools for AI agents
+ */
+export declare class MCPConversationToolset {
+    private brain;
+    private conversationManager;
+    private initialized;
+    /**
+     * Create MCP Conversation Toolset
+     * @param brain Brainy instance
+     */
+    constructor(brain: Brainy);
+    /**
+     * Initialize the toolset
+     */
+    init(): Promise<void>;
+    /**
+     * Handle MCP tool execution request
+     * @param request MCP tool execution request
+     * @returns MCP response
+     */
+    handleRequest(request: MCPToolExecutionRequest): Promise<MCPResponse>;
+    /**
+     * Get available conversation tools
+     * @returns Array of MCP tool definitions
+     */
+    getAvailableTools(): Promise<MCPTool[]>;
+    /**
+     * Handle save_message tool
+     * REAL: Uses ConversationManager.saveMessage()
+     */
+    private handleSaveMessage;
+    /**
+     * Handle get_context tool
+     * REAL: Uses ConversationManager.getRelevantContext()
+     */
+    private handleGetContext;
+    /**
+     * Handle search tool
+     * REAL: Uses ConversationManager.searchMessages()
+     */
+    private handleSearch;
+    /**
+     * Handle get_thread tool
+     * REAL: Uses ConversationManager.getConversationThread()
+     */
+    private handleGetThread;
+    /**
+     * Handle save_artifact tool
+     * REAL: Uses ConversationManager.saveArtifact()
+     */
+    private handleSaveArtifact;
+    /**
+     * Handle find_similar tool
+     * REAL: Uses ConversationManager.findSimilarConversations()
+     */
+    private handleFindSimilar;
+    /**
+     * Create success response
+     */
+    private createSuccessResponse;
+    /**
+     * Create error response
+     */
+    private createErrorResponse;
+    /**
+     * Generate request ID
+     */
+    generateRequestId(): string;
+}
+/**
+ * Create MCP conversation toolset
+ * @param brain Brainy instance
+ * @returns MCPConversationToolset instance
+ */
+export declare function createConversationToolset(brain: Brainy): MCPConversationToolset;