memory-engineering/src/tools/memory-active-context.ts

Advanced Memory-Aware Code Context System with claude-flow-inspired architecture, showcasing MongoDB + Voyage AI strategic positioning

/**
 * Memory Active Context Tool
 * Using claude-flow-inspired MemoryManager for conflict-free operations
 */

import { Tool } from '@modelcontextprotocol/sdk/types.js';
import { IMemoryManager } from '../memory/memory-manager.js';
import { generateMemoryId } from '../utils/id-generator.js';
import { logger } from '../utils/logger.js';

export const memoryActiveContextTool: Tool = {
  name: 'memory_active_context',
  description: 'Track current work and active context',
  inputSchema: {
    type: 'object',
    properties: {
      projectPath: { type: 'string', description: 'Project path' },
      currentTask: { type: 'string', description: 'Current task description' },
      recentChanges: { 
        type: 'array', 
        items: {
          type: 'object',
          properties: {
            change: { type: 'string' },
            impact: { type: 'string' }
          }
        }
      },
      nextSteps: { type: 'array', items: { type: 'string' } },
      blockers: { type: 'array', items: { type: 'string' } }
    },
    required: ['projectPath', 'currentTask', 'recentChanges', 'nextSteps', 'blockers']
  }
};

export function createMemoryActiveContextHandler(memoryManager: IMemoryManager) {
  return async (args: any) => {
    try {
      const { projectPath, currentTask, recentChanges, nextSteps, blockers } = args;

      const content = { currentTask, recentChanges, nextSteps, blockers };
      const searchableText = `${currentTask} ${recentChanges.map((c: any) => `${c.change} ${c.impact}`).join(' ')} ${nextSteps.join(' ')} ${blockers.join(' ')}`;

      const memoryId = generateMemoryId(projectPath, 'active');
      const existing = await memoryManager.retrieve(memoryId);

      const memoryEntry = {
        id: memoryId,
        projectPath,
        memoryType: 'active',
        content,
        context: {
          currentTask,
          recentChangesCount: recentChanges.length,
          nextStepsCount: nextSteps.length,
          blockersCount: blockers.length,
          sessionId: process.env.MCP_SESSION_ID
        },
        timestamp: new Date(),
        tags: ['active', 'current-work', 'task-tracking'],
        version: existing ? (existing.version + 1) : 1,
        metadata: {
          created: existing?.metadata?.created || new Date(),
          lastUpdated: new Date(),
          accessCount: ((existing?.metadata?.accessCount as number) || 0) + 1,
          lastAccessed: new Date(),
        },
        searchableText
      };

      const storedId = await memoryManager.store(memoryEntry);

      logger.info('Active context updated', {
        projectPath,
        currentTask: currentTask.substring(0, 100),
        hasBlockers: blockers.length > 0,
        memoryId: storedId,
        isNew: !existing,
        version: memoryEntry.version
      });

      return {
        content: [{
          type: 'text',
          text: `✅ Active context updated!\n\nCurrent focus is tracked.\n\n📋 **Summary:**\n- Task: ${currentTask.substring(0, 100)}${currentTask.length > 100 ? '...' : ''}\n- Recent changes: ${recentChanges.length}\n- Next steps: ${nextSteps.length}\n- Blockers: ${blockers.length}\n\n🎯 Context helps maintain focus across sessions.`
        }],
        isError: false
      };
    } catch (error) {
      logger.error('Failed to update active context', error);
      return {
        content: [{ type: 'text', text: `❌ Error: ${error instanceof Error ? error.message : 'Unknown error'}` }],
        isError: true
      };
    }
  };
}