@sesamespace/hivemind 0.10.0 → 0.11.1

package/src/memory/processors/agent-sync.ts

@@ -0,0 +1,312 @@
+/**
+ * Agent Sync - Shares knowledge between multiple Hivemind agents
+ */
+
+import { BackgroundProcessor } from './background-processor';
+import { EventEmitter } from 'events';
+import axios from 'axios';
+
+export interface AgentKnowledge {
+  agentId: string;
+  agentName: string;
+  context: string;
+  tasks: SharedTask[];
+  insights: string[];
+  capabilities: string[];
+  lastSync: Date;
+}
+
+export interface SharedTask {
+  id: string;
+  description: string;
+  status: 'active' | 'completed' | 'blocked';
+  assignedTo: string;
+  dependencies: string[];
+  progress: number;
+  notes: string[];
+}
+
+export interface SyncMessage {
+  type: 'task-update' | 'insight' | 'handoff' | 'capability';
+  fromAgent: string;
+  toAgent?: string; // Optional for broadcasts
+  payload: any;
+  timestamp: Date;
+}
+
+export class AgentSync extends BackgroundProcessor {
+  private agentId: string;
+  private agentName: string;
+  private otherAgents: Map<string, AgentKnowledge> = new Map();
+  private syncQueue: SyncMessage[] = [];
+  private sharedTasks: Map<string, SharedTask> = new Map();
+  private syncEndpoints: Map<string, string> = new Map(); // agentId -> endpoint
+
+  constructor(agentId: string, agentName: string) {
+    super('agent-sync', 30000); // Sync every 30 seconds
+    this.agentId = agentId;
+    this.agentName = agentName;
+  }
+
+  async process(): Promise<void> {
+    // Process outgoing sync messages
+    await this.processSyncQueue();
+
+    // Pull updates from other agents
+    await this.pullUpdates();
+
+    // Check for stale tasks that might need handoff
+    await this.checkHandoffs();
+
+    this.emit('sync-complete', {
+      agentsKnown: this.otherAgents.size,
+      sharedTasks: this.sharedTasks.size,
+      queuedMessages: this.syncQueue.length
+    });
+  }
+
+  /**
+   * Register another agent for syncing
+   */
+  async registerAgent(agentId: string, agentName: string, endpoint: string): Promise<void> {
+    this.syncEndpoints.set(agentId, endpoint);
+    this.otherAgents.set(agentId, {
+      agentId,
+      agentName,
+      context: 'unknown',
+      tasks: [],
+      insights: [],
+      capabilities: [],
+      lastSync: new Date()
+    });
+  }
+
+  /**
+   * Share a task with other agents
+   */
+  async shareTask(task: Omit<SharedTask, 'id'>): Promise<string> {
+    const taskId = `${this.agentId}-${Date.now()}`;
+    const sharedTask: SharedTask = {
+      id: taskId,
+      ...task
+    };
+
+    this.sharedTasks.set(taskId, sharedTask);
+    
+    // Broadcast task to other agents
+    this.queueSync({
+      type: 'task-update',
+      fromAgent: this.agentId,
+      payload: sharedTask,
+      timestamp: new Date()
+    });
+
+    return taskId;
+  }
+
+  /**
+   * Share an insight learned during work
+   */
+  async shareInsight(insight: string, context?: string): Promise<void> {
+    this.queueSync({
+      type: 'insight',
+      fromAgent: this.agentId,
+      payload: { insight, context },
+      timestamp: new Date()
+    });
+  }
+
+  /**
+   * Announce a new capability
+   */
+  async announceCapability(capability: string): Promise<void> {
+    this.queueSync({
+      type: 'capability',
+      fromAgent: this.agentId,
+      payload: { capability },
+      timestamp: new Date()
+    });
+  }
+
+  /**
+   * Request handoff of a task to another agent
+   */
+  async requestHandoff(taskId: string, toAgent: string, reason: string): Promise<void> {
+    const task = this.sharedTasks.get(taskId);
+    if (!task) return;
+
+    this.queueSync({
+      type: 'handoff',
+      fromAgent: this.agentId,
+      toAgent,
+      payload: { taskId, task, reason },
+      timestamp: new Date()
+    });
+  }
+
+  private queueSync(message: SyncMessage): void {
+    this.syncQueue.push(message);
+  }
+
+  private async processSyncQueue(): Promise<void> {
+    while (this.syncQueue.length > 0) {
+      const message = this.syncQueue.shift();
+      if (!message) continue;
+
+      if (message.toAgent) {
+        // Direct message to specific agent
+        await this.sendToAgent(message.toAgent, message);
+      } else {
+        // Broadcast to all agents
+        for (const agentId of this.syncEndpoints.keys()) {
+          if (agentId !== this.agentId) {
+            await this.sendToAgent(agentId, message);
+          }
+        }
+      }
+    }
+  }
+
+  private async sendToAgent(agentId: string, message: SyncMessage): Promise<void> {
+    const endpoint = this.syncEndpoints.get(agentId);
+    if (!endpoint) return;
+
+    try {
+      await axios.post(`${endpoint}/sync`, message, {
+        timeout: 5000,
+        headers: {
+          'X-Agent-ID': this.agentId,
+          'X-Agent-Name': this.agentName
+        }
+      });
+    } catch (error) {
+      this.emit('sync-error', { agentId, error });
+    }
+  }
+
+  private async pullUpdates(): Promise<void> {
+    for (const [agentId, endpoint] of this.syncEndpoints) {
+      if (agentId === this.agentId) continue;
+
+      try {
+        const response = await axios.get(`${endpoint}/sync/updates`, {
+          params: {
+            since: this.otherAgents.get(agentId)?.lastSync.toISOString()
+          },
+          timeout: 5000,
+          headers: {
+            'X-Agent-ID': this.agentId
+          }
+        });
+
+        if (response.data.updates) {
+          await this.processUpdates(agentId, response.data.updates);
+        }
+      } catch (error) {
+        this.emit('pull-error', { agentId, error });
+      }
+    }
+  }
+
+  private async processUpdates(fromAgent: string, updates: SyncMessage[]): Promise<void> {
+    const agentKnowledge = this.otherAgents.get(fromAgent);
+    if (!agentKnowledge) return;
+
+    for (const update of updates) {
+      switch (update.type) {
+        case 'task-update':
+          const task = update.payload as SharedTask;
+          this.sharedTasks.set(task.id, task);
+          agentKnowledge.tasks = agentKnowledge.tasks.filter(t => t.id !== task.id);
+          agentKnowledge.tasks.push(task);
+          break;
+
+        case 'insight':
+          const { insight } = update.payload;
+          if (!agentKnowledge.insights.includes(insight)) {
+            agentKnowledge.insights.push(insight);
+          }
+          break;
+
+        case 'capability':
+          const { capability } = update.payload;
+          if (!agentKnowledge.capabilities.includes(capability)) {
+            agentKnowledge.capabilities.push(capability);
+          }
+          break;
+
+        case 'handoff':
+          if (update.toAgent === this.agentId) {
+            await this.handleHandoff(update.payload);
+          }
+          break;
+      }
+    }
+
+    agentKnowledge.lastSync = new Date();
+  }
+
+  private async handleHandoff(payload: any): Promise<void> {
+    const { taskId, task, reason } = payload;
+    
+    // Accept the handoff
+    task.assignedTo = this.agentName;
+    this.sharedTasks.set(taskId, task);
+
+    this.emit('handoff-received', { taskId, task, reason });
+
+    // Acknowledge the handoff
+    this.queueSync({
+      type: 'task-update',
+      fromAgent: this.agentId,
+      payload: task,
+      timestamp: new Date()
+    });
+  }
+
+  private async checkHandoffs(): Promise<void> {
+    // Check for tasks that might need handoff
+    for (const task of this.sharedTasks.values()) {
+      if (task.assignedTo === this.agentName && task.status === 'blocked') {
+        // Check if another agent might be better suited
+        const betterAgent = this.findBetterAgent(task);
+        if (betterAgent) {
+          await this.requestHandoff(
+            task.id,
+            betterAgent,
+            'Task blocked, another agent may have required capabilities'
+          );
+        }
+      }
+    }
+  }
+
+  private findBetterAgent(task: SharedTask): string | null {
+    // Simple heuristic: find agent with relevant capabilities
+    for (const [agentId, knowledge] of this.otherAgents) {
+      // Check if agent has capabilities mentioned in task notes
+      for (const note of task.notes) {
+        for (const capability of knowledge.capabilities) {
+          if (note.toLowerCase().includes(capability.toLowerCase())) {
+            return agentId;
+          }
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Get knowledge about other agents
+   */
+  async getAgentKnowledge(): Promise<AgentKnowledge[]> {
+    return Array.from(this.otherAgents.values());
+  }
+
+  /**
+   * Get all shared tasks
+   */
+  async getSharedTasks(): Promise<SharedTask[]> {
+    return Array.from(this.sharedTasks.values());
+  }
+}

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;
+    }
+  }
+}