@sesamespace/hivemind 0.8.9 → 0.8.11

package/src/memory/processors/command-learner.ts

@@ -0,0 +1,298 @@
+/**
+ * Command Learner - Tracks successful command patterns and builds a knowledge base
+ */
+
+import { BackgroundProcessor } from './background-processor';
+import { EventEmitter } from 'events';
+
+export interface CommandPattern {
+  pattern: string;
+  description: string;
+  examples: CommandExample[];
+  successRate: number;
+  category: string;
+  relatedCommands: string[];
+  lastUsed: Date;
+  usageCount: number;
+}
+
+export interface CommandExample {
+  command: string;
+  context: string;
+  output?: string;
+  success: boolean;
+  timestamp: Date;
+}
+
+export class CommandLearner extends BackgroundProcessor {
+  private patterns: Map<string, CommandPattern> = new Map();
+  private recentCommands: CommandExample[] = [];
+  private categoryIndex: Map<string, Set<string>> = new Map();
+
+  constructor() {
+    super('command-learner', 60000); // Process every minute
+  }
+
+  async process(): Promise<void> {
+    // Analyze recent commands to extract patterns
+    if (this.recentCommands.length >= 5) {
+      await this.extractPatterns();
+    }
+
+    // Update success rates
+    this.updateSuccessRates();
+
+    // Emit current state
+    this.emit('patterns-updated', {
+      totalPatterns: this.patterns.size,
+      categories: Array.from(this.categoryIndex.keys()),
+      recentCommands: this.recentCommands.length
+    });
+  }
+
+  /**
+   * Track a command execution
+   */
+  async trackCommand(command: string, context: string, output?: string, success: boolean = true): Promise<void> {
+    const example: CommandExample = {
+      command,
+      context,
+      output: output?.substring(0, 1000), // Limit output size
+      success,
+      timestamp: new Date()
+    };
+
+    this.recentCommands.push(example);
+    
+    // Keep only last 100 commands
+    if (this.recentCommands.length > 100) {
+      this.recentCommands.shift();
+    }
+
+    // Check if this matches an existing pattern
+    await this.matchToPattern(example);
+  }
+
+  private async extractPatterns(): Promise<void> {
+    // Group commands by similarity
+    const groups = this.groupSimilarCommands(this.recentCommands.slice(-20));
+
+    for (const group of groups) {
+      if (group.length >= 2) {
+        const pattern = this.derivePattern(group);
+        if (pattern) {
+          this.patterns.set(pattern.pattern, pattern);
+          
+          // Index by category
+          if (!this.categoryIndex.has(pattern.category)) {
+            this.categoryIndex.set(pattern.category, new Set());
+          }
+          this.categoryIndex.get(pattern.category)!.add(pattern.pattern);
+        }
+      }
+    }
+  }
+
+  private groupSimilarCommands(commands: CommandExample[]): CommandExample[][] {
+    const groups: CommandExample[][] = [];
+    const used = new Set<number>();
+
+    for (let i = 0; i < commands.length; i++) {
+      if (used.has(i)) continue;
+
+      const group = [commands[i]];
+      used.add(i);
+
+      for (let j = i + 1; j < commands.length; j++) {
+        if (used.has(j)) continue;
+        
+        if (this.areSimilar(commands[i].command, commands[j].command)) {
+          group.push(commands[j]);
+          used.add(j);
+        }
+      }
+
+      if (group.length > 1) {
+        groups.push(group);
+      }
+    }
+
+    return groups;
+  }
+
+  private areSimilar(cmd1: string, cmd2: string): boolean {
+    // Tokenize commands
+    const tokens1 = cmd1.split(/\s+/);
+    const tokens2 = cmd2.split(/\s+/);
+
+    // Check if base command is the same
+    if (tokens1[0] !== tokens2[0]) return false;
+
+    // Check structural similarity
+    if (Math.abs(tokens1.length - tokens2.length) > 2) return false;
+
+    // Count matching tokens (excluding file paths and specific values)
+    let matches = 0;
+    for (let i = 0; i < Math.min(tokens1.length, tokens2.length); i++) {
+      if (tokens1[i] === tokens2[i] || 
+          (this.isVariable(tokens1[i]) && this.isVariable(tokens2[i]))) {
+        matches++;
+      }
+    }
+
+    return matches / Math.max(tokens1.length, tokens2.length) > 0.6;
+  }
+
+  private isVariable(token: string): boolean {
+    // Detect tokens that are likely variables (paths, URLs, IDs, etc.)
+    return token.includes('/') || 
+           token.includes('.') || 
+           token.match(/^[a-f0-9]{8,}$/i) !== null ||
+           token.match(/^\d+$/) !== null;
+  }
+
+  private derivePattern(examples: CommandExample[]): CommandPattern | null {
+    if (examples.length === 0) return null;
+
+    const baseCmd = examples[0].command.split(/\s+/)[0];
+    const category = this.categorizeCommand(baseCmd);
+
+    // Find common structure
+    const tokenizedExamples = examples.map(e => e.command.split(/\s+/));
+    const patternTokens: string[] = [];
+
+    for (let i = 0; i < tokenizedExamples[0].length; i++) {
+      const tokensAtPosition = tokenizedExamples.map(t => t[i]).filter(Boolean);
+      
+      if (tokensAtPosition.every(t => t === tokensAtPosition[0])) {
+        patternTokens.push(tokensAtPosition[0]);
+      } else if (tokensAtPosition.every(t => this.isVariable(t))) {
+        patternTokens.push('<variable>');
+      } else {
+        patternTokens.push('<option>');
+      }
+    }
+
+    const pattern = patternTokens.join(' ');
+    const successCount = examples.filter(e => e.success).length;
+
+    return {
+      pattern,
+      description: this.generateDescription(pattern, examples),
+      examples: examples.slice(0, 5), // Keep top 5 examples
+      successRate: successCount / examples.length,
+      category,
+      relatedCommands: this.findRelatedCommands(baseCmd),
+      lastUsed: new Date(Math.max(...examples.map(e => e.timestamp.getTime()))),
+      usageCount: examples.length
+    };
+  }
+
+  private categorizeCommand(baseCmd: string): string {
+    const categories: Record<string, string[]> = {
+      'git': ['git', 'gh'],
+      'file': ['ls', 'cat', 'cp', 'mv', 'rm', 'find', 'grep'],
+      'process': ['ps', 'kill', 'top', 'htop'],
+      'network': ['curl', 'wget', 'ping', 'netstat'],
+      'package': ['npm', 'yarn', 'pip', 'brew'],
+      'docker': ['docker', 'docker-compose'],
+      'system': ['df', 'du', 'free', 'uname']
+    };
+
+    for (const [category, commands] of Object.entries(categories)) {
+      if (commands.includes(baseCmd)) {
+        return category;
+      }
+    }
+
+    return 'other';
+  }
+
+  private generateDescription(pattern: string, examples: CommandExample[]): string {
+    const baseCmd = pattern.split(' ')[0];
+    const contexts = [...new Set(examples.map(e => e.context))];
+    
+    return `${baseCmd} command used for ${contexts.join(', ')}`;
+  }
+
+  private findRelatedCommands(baseCmd: string): string[] {
+    const related: Record<string, string[]> = {
+      'git': ['git status', 'git log', 'git diff'],
+      'npm': ['npm install', 'npm run', 'npm test'],
+      'docker': ['docker ps', 'docker logs', 'docker exec'],
+      'curl': ['wget', 'httpie', 'fetch']
+    };
+
+    return related[baseCmd] || [];
+  }
+
+  private async matchToPattern(example: CommandExample): Promise<void> {
+    for (const [patternStr, pattern] of this.patterns) {
+      if (this.matchesPattern(example.command, patternStr)) {
+        pattern.examples.push(example);
+        pattern.lastUsed = example.timestamp;
+        pattern.usageCount++;
+        
+        // Keep only recent examples
+        if (pattern.examples.length > 10) {
+          pattern.examples = pattern.examples.slice(-10);
+        }
+        
+        break;
+      }
+    }
+  }
+
+  private matchesPattern(command: string, pattern: string): boolean {
+    const cmdTokens = command.split(/\s+/);
+    const patternTokens = pattern.split(/\s+/);
+
+    if (cmdTokens.length !== patternTokens.length) return false;
+
+    for (let i = 0; i < cmdTokens.length; i++) {
+      if (patternTokens[i] === '<variable>' || patternTokens[i] === '<option>') {
+        continue;
+      }
+      if (cmdTokens[i] !== patternTokens[i]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  private updateSuccessRates(): void {
+    for (const pattern of this.patterns.values()) {
+      const recentExamples = pattern.examples.slice(-10);
+      const successCount = recentExamples.filter(e => e.success).length;
+      pattern.successRate = successCount / recentExamples.length;
+    }
+  }
+
+  /**
+   * Get command suggestions for a given context
+   */
+  async getSuggestions(context: string, category?: string): Promise<CommandPattern[]> {
+    let patterns = Array.from(this.patterns.values());
+
+    // Filter by category if specified
+    if (category && this.categoryIndex.has(category)) {
+      const categoryPatterns = this.categoryIndex.get(category)!;
+      patterns = patterns.filter(p => categoryPatterns.has(p.pattern));
+    }
+
+    // Filter by context relevance
+    patterns = patterns.filter(p => 
+      p.examples.some(e => e.context.toLowerCase().includes(context.toLowerCase()))
+    );
+
+    // Sort by success rate and recency
+    return patterns
+      .sort((a, b) => {
+        const scoreA = a.successRate * 0.7 + (Date.now() - a.lastUsed.getTime() < 3600000 ? 0.3 : 0);
+        const scoreB = b.successRate * 0.7 + (Date.now() - b.lastUsed.getTime() < 3600000 ? 0.3 : 0);
+        return scoreB - scoreA;
+      })
+      .slice(0, 5);
+  }
+}

package/src/memory/processors/memory-api-client.ts

@@ -0,0 +1,105 @@
+/**
+ * Client for interacting with the Hivemind memory daemon API
+ */
+
+import axios from 'axios';
+import { EventEmitter } from 'events';
+
+export interface MemorySearchResult {
+  content: string;
+  similarity: number;
+  metadata?: Record<string, any>;
+}
+
+export interface L3Knowledge {
+  insight: string;
+  confidence: number;
+  sources: string[];
+}
+
+export interface MemoryStats {
+  episodes: number;
+  contexts: string[];
+  l3Entries: number;
+}
+
+export class MemoryAPIClient extends EventEmitter {
+  private baseURL: string;
+  private context: string;
+
+  constructor(baseURL: string = 'http://localhost:3434', context: string = 'global') {
+    super();
+    this.baseURL = baseURL;
+    this.context = context;
+  }
+
+  async health(): Promise<boolean> {
+    try {
+      const response = await axios.get(`${this.baseURL}/health`);
+      return response.status === 200;
+    } catch (error) {
+      this.emit('error', error);
+      return false;
+    }
+  }
+
+  async search(query: string, limit: number = 10): Promise<MemorySearchResult[]> {
+    try {
+      const response = await axios.get(`${this.baseURL}/search`, {
+        params: { q: query, context: this.context, limit }
+      });
+      return response.data.results || [];
+    } catch (error) {
+      this.emit('error', error);
+      return [];
+    }
+  }
+
+  async crossSearch(query: string, limit: number = 10): Promise<MemorySearchResult[]> {
+    try {
+      const response = await axios.get(`${this.baseURL}/cross-search`, {
+        params: { q: query, limit }
+      });
+      return response.data.results || [];
+    } catch (error) {
+      this.emit('error', error);
+      return [];
+    }
+  }
+
+  async getL3Knowledge(): Promise<L3Knowledge[]> {
+    try {
+      const response = await axios.get(`${this.baseURL}/promotion/l3`, {
+        params: { context: this.context }
+      });
+      return response.data.knowledge || [];
+    } catch (error) {
+      this.emit('error', error);
+      return [];
+    }
+  }
+
+  async getStats(): Promise<MemoryStats | null> {
+    try {
+      const response = await axios.get(`${this.baseURL}/stats`);
+      return response.data;
+    } catch (error) {
+      this.emit('error', error);
+      return null;
+    }
+  }
+
+  async store(content: string, metadata?: Record<string, any>): Promise<boolean> {
+    try {
+      const response = await axios.post(`${this.baseURL}/store`, {
+        context: this.context,
+        content,
+        metadata
+      });
+      return response.status === 200;
+    } catch (error) {
+      this.emit('error', error);
+      return false;
+    }
+  }
+}

package/src/memory/processors/message-flow-integration.ts

@@ -0,0 +1,168 @@
+/**
+ * Integrates memory processors with the agent's message flow
+ */
+
+import { EventEmitter } from 'events';
+import { MemoryAPIClient } from './memory-api-client';
+import { ProcessManager } from './background-processor';
+import { CodeIndexer } from './code-indexer';
+import { TaskTracker } from './task-tracker';
+import { ContextManager } from './context-manager';
+
+export interface AgentMessage {
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+  timestamp: Date;
+  context?: string;
+  metadata?: Record<string, any>;
+}
+
+export interface MessageFlowConfig {
+  memoryURL?: string;
+  context?: string;
+  workspaceRoot: string;
+  maxContextTokens?: number;
+}
+
+export class MessageFlowIntegration extends EventEmitter {
+  private memoryClient: MemoryAPIClient;
+  private processManager: ProcessManager;
+  private contextManager: ContextManager;
+  private taskTracker: TaskTracker;
+  private codeIndexer: CodeIndexer;
+
+  constructor(config: MessageFlowConfig) {
+    super();
+    
+    // Initialize memory client
+    this.memoryClient = new MemoryAPIClient(
+      config.memoryURL || 'http://localhost:3434',
+      config.context || 'global'
+    );
+
+    // Initialize processors
+    this.processManager = new ProcessManager();
+    this.codeIndexer = new CodeIndexer(config.workspaceRoot);
+    this.taskTracker = new TaskTracker();
+    
+    // Initialize context manager
+    this.contextManager = new ContextManager(
+      this.memoryClient,
+      this.processManager,
+      config.maxContextTokens || 8000
+    );
+
+    // Register processors
+    this.processManager.register('code-indexer', this.codeIndexer);
+    this.processManager.register('task-tracker', this.taskTracker);
+
+    // Set up event listeners
+    this.setupEventListeners();
+  }
+
+  private setupEventListeners(): void {
+    // Forward errors
+    this.memoryClient.on('error', (error) => {
+      this.emit('error', { source: 'memory-client', error });
+    });
+
+    this.processManager.on('processor-error', (data) => {
+      this.emit('error', { source: 'processor', ...data });
+    });
+
+    // Track file access from messages
+    this.on('message', (message: AgentMessage) => {
+      if (message.role === 'assistant') {
+        this.extractFileReferences(message.content);
+      }
+    });
+  }
+
+  private extractFileReferences(content: string): void {
+    // Extract file paths from message content
+    const filePathRegex = /(?:\/[\w.-]+)+(?:\.[\w]+)?/g;
+    const matches = content.match(filePathRegex) || [];
+    
+    for (const match of matches) {
+      if (match.includes('.') && !match.includes('http')) {
+        this.codeIndexer.trackAccess(match);
+      }
+    }
+  }
+
+  async start(): Promise<void> {
+    // Check memory daemon health
+    const isHealthy = await this.memoryClient.health();
+    if (!isHealthy) {
+      throw new Error('Memory daemon is not responding');
+    }
+
+    // Start background processors
+    await this.processManager.startAll();
+    
+    this.emit('started');
+  }
+
+  async stop(): Promise<void> {
+    await this.processManager.stopAll();
+    this.emit('stopped');
+  }
+
+  /**
+   * Process an incoming message and return enriched context
+   */
+  async processMessage(message: AgentMessage): Promise<string> {
+    // Store the message in memory
+    await this.memoryClient.store(
+      `${message.role}: ${message.content}`,
+      {
+        timestamp: message.timestamp.toISOString(),
+        context: message.context,
+        ...message.metadata
+      }
+    );
+
+    // Update task tracker
+    if (message.role === 'user') {
+      await this.taskTracker.processMessage(message.content, 'user');
+    } else if (message.role === 'assistant') {
+      await this.taskTracker.processMessage(message.content, 'assistant');
+    }
+
+    // Build context for the next response
+    const context = await this.contextManager.buildContext(message.content);
+    
+    this.emit('context-built', {
+      message,
+      contextLength: context.length,
+      sections: this.contextManager['contextSections'].length // Track what was included
+    });
+
+    return context;
+  }
+
+  /**
+   * Get current state of all processors
+   */
+  async getState(): Promise<Record<string, any>> {
+    const stats = await this.memoryClient.getStats();
+    const tasks = await this.taskTracker.getActiveTasks();
+    const workingSet = await this.codeIndexer.getWorkingSet();
+
+    return {
+      memory: stats,
+      tasks: tasks.map(t => ({
+        description: t.description,
+        state: t.state,
+        startTime: t.startTime,
+        lastUpdate: t.lastUpdate
+      })),
+      workingSet: workingSet.map(f => ({
+        path: f.path,
+        accessCount: f.accessCount,
+        lastAccessed: f.lastAccessed
+      })),
+      processors: this.processManager['processors'].size
+    };
+  }
+}