polydev-ai 1.0.0 → 1.1.0

package/mcp/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-perspectives",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Agentic workflow assistant - get diverse perspectives from multiple LLMs when stuck or need enhanced reasoning",
   "author": "Polydev AI",
   "license": "MIT",
@@ -441,6 +441,232 @@
           }
         }
       ]
+    },
+    {
+      "name": "polydev.detect_memory_sources",
+      "description": "Detect all available memory sources across CLI tools (Claude Code, Cline, Codex, Cursor, Continue, Aider). Returns file paths for global memory, project memory, and recent conversations.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "project_path": {
+            "type": "string",
+            "description": "Project directory path to scan for memory sources",
+            "default": "."
+          },
+          "cli_tools": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "enum": ["claude_code", "cline", "codex_cli", "cursor", "continue", "aider", "generic", "all"]
+            },
+            "description": "CLI tools to detect memory for",
+            "default": ["all"]
+          },
+          "memory_types": {
+            "type": "array", 
+            "items": {
+              "type": "string",
+              "enum": ["global", "project", "conversation", "config"]
+            },
+            "description": "Types of memory to detect",
+            "default": ["global", "project", "conversation"]
+          }
+        }
+      },
+      "outputSchema": {
+        "type": "object",
+        "properties": {
+          "success": { "type": "boolean" },
+          "sources": {
+            "type": "array",
+            "items": {
+              "type": "object", 
+              "properties": {
+                "cli_tool": { "type": "string" },
+                "memory_type": { "type": "string" },
+                "file_path": { "type": "string" },
+                "exists": { "type": "boolean" },
+                "size_bytes": { "type": "number" },
+                "last_modified": { "type": "string" }
+              }
+            }
+          },
+          "summary": {
+            "type": "object",
+            "properties": {
+              "total_sources": { "type": "number" },
+              "sources_by_tool": { "type": "object" },
+              "sources_by_type": { "type": "object" }
+            }
+          }
+        }
+      }
+    },
+    {
+      "name": "polydev.extract_memory", 
+      "description": "Extract and optionally encrypt memory content from detected CLI tool sources. Provides TF-IDF relevance scoring and content analysis.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "user_token": {
+            "type": "string",
+            "description": "Polydev user authentication token for server storage",
+            "minLength": 1
+          },
+          "project_path": {
+            "type": "string", 
+            "description": "Project directory path",
+            "default": "."
+          },
+          "cli_tools": {
+            "type": "array",
+            "items": { "type": "string" },
+            "default": ["all"]
+          },
+          "memory_types": {
+            "type": "array",
+            "items": { "type": "string" },
+            "default": ["global", "project", "conversation"]
+          },
+          "encryption_enabled": { 
+            "type": "boolean", 
+            "description": "Enable zero-knowledge encryption for extracted content",
+            "default": true 
+          },
+          "max_file_size_kb": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 1000,
+            "default": 500
+          },
+          "relevance_threshold": {
+            "type": "number",
+            "minimum": 0,
+            "maximum": 1,
+            "default": 0.3
+          }
+        },
+        "required": ["user_token"]
+      }
+    },
+    {
+      "name": "polydev.get_recent_conversations",
+      "description": "Get recent conversations from CLI tools with TF-IDF relevance scoring against query context. Supports encrypted storage and retrieval.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "user_token": {
+            "type": "string",
+            "description": "Polydev user authentication token",
+            "minLength": 1
+          },
+          "query_context": { 
+            "type": "string", 
+            "description": "Current query for relevance scoring and context matching"
+          },
+          "limit": { 
+            "type": "integer", 
+            "minimum": 1, 
+            "maximum": 50, 
+            "default": 6 
+          },
+          "cli_tools": { 
+            "type": "array", 
+            "items": { "type": "string" },
+            "default": ["all"] 
+          },
+          "time_range_hours": { 
+            "type": "integer", 
+            "minimum": 1, 
+            "maximum": 168, 
+            "default": 24 
+          },
+          "project_path": {
+            "type": "string",
+            "default": "."
+          }
+        },
+        "required": ["user_token"]
+      }
+    },
+    {
+      "name": "polydev.get_memory_context",
+      "description": "Get formatted memory and conversation context for injection into prompts. Automatically handles decryption and relevance scoring.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "user_token": {
+            "type": "string",
+            "description": "Polydev user authentication token", 
+            "minLength": 1
+          },
+          "query_context": {
+            "type": "string",
+            "description": "Query to find relevant memory and conversations for"
+          },
+          "max_memory_kb": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 200,
+            "default": 50
+          },
+          "max_conversations": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 20,
+            "default": 6
+          },
+          "cli_tools": {
+            "type": "array",
+            "items": { "type": "string" },
+            "default": ["all"]
+          },
+          "memory_types": {
+            "type": "array",
+            "items": { "type": "string" },
+            "default": ["project", "conversation"]
+          }
+        },
+        "required": ["user_token"]
+      }
+    },
+    {
+      "name": "polydev.manage_memory_preferences", 
+      "description": "Configure memory extraction and privacy preferences. Control which CLI tools and memory types are enabled, encryption settings, and context injection behavior.",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "user_token": {
+            "type": "string",
+            "description": "Polydev user authentication token",
+            "minLength": 1
+          },
+          "action": {
+            "type": "string",
+            "enum": ["get", "update"],
+            "description": "Action to perform",
+            "default": "get"
+          },
+          "preferences": {
+            "type": "object",
+            "description": "Memory preferences to update",
+            "properties": {
+              "memory_enabled": { "type": "boolean" },
+              "privacy_mode": { "type": "boolean" },
+              "auto_extraction": { "type": "boolean" },
+              "cli_tools_enabled": { "type": "object" },
+              "memory_types_enabled": { "type": "object" },
+              "auto_inject_context": { "type": "boolean" },
+              "context_relevance_threshold": { "type": "number", "minimum": 0, "maximum": 1 },
+              "max_conversations_inject": { "type": "integer" },
+              "max_memory_inject_kb": { "type": "integer" },
+              "key_rotation_days": { "type": "integer" },
+              "cache_ttl_minutes": { "type": "integer" }
+            }
+          }
+        },
+        "required": ["user_token"]
+      }
     }
   ],
   "configuration": {

package/mcp/server.js

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const path = require('path');
 const CLIManager = require('../lib/cliManager').default;
+const UniversalMemoryExtractor = require('../src/lib/universalMemoryExtractor').UniversalMemoryExtractor;
 
 class MCPServer {
   constructor() {
@@ -14,6 +15,7 @@ class MCPServer {
     
     this.tools = new Map();
     this.cliManager = new CLIManager();
+    this.memoryExtractor = new UniversalMemoryExtractor();
     this.loadManifest();
   }
 
@@ -136,6 +138,26 @@ class MCPServer {
           result = await this.sendCliPrompt(args);
           break;
         
+        case 'polydev.detect_memory_sources':
+          result = await this.detectMemorySources(args);
+          break;
+        
+        case 'polydev.extract_memory':
+          result = await this.extractMemory(args);
+          break;
+        
+        case 'polydev.get_recent_conversations':
+          result = await this.getRecentConversations(args);
+          break;
+        
+        case 'polydev.get_memory_context':
+          result = await this.getMemoryContext(args);
+          break;
+        
+        case 'polydev.manage_memory_preferences':
+          result = await this.manageMemoryPreferences(args);
+          break;
+        
         default:
           throw new Error(`Tool ${name} not implemented`);
       }
@@ -172,6 +194,30 @@ class MCPServer {
       throw new Error('prompt is required and must be a string');
     }
 
+    // Auto-inject memory context if enabled and not already provided
+    let enhancedPrompt = args.prompt;
+    if (!args.project_memory && args.auto_inject_memory !== false) {
+      try {
+        console.error('[Polydev MCP] Attempting to inject memory context...');
+        const memoryContext = await this.getMemoryContext({
+          prompt: args.prompt,
+          cli_tools: ['all'],
+          max_entries: 3
+        });
+        
+        if (memoryContext.success && memoryContext.context.entries.length > 0) {
+          const contextText = memoryContext.context.entries
+            .map(entry => `[${entry.source}] ${entry.content.substring(0, 500)}`)
+            .join('\n\n');
+          
+          enhancedPrompt = `Context from previous work:\n${contextText}\n\nCurrent request:\n${args.prompt}`;
+          console.error(`[Polydev MCP] Injected ${memoryContext.context.entries.length} memory entries`);
+        }
+      } catch (error) {
+        console.error('[Polydev MCP] Memory injection failed, continuing without:', error.message);
+      }
+    }
+
     // Support both parameter token (Claude Code) and environment token (Cline)
     const userToken = args.user_token || process.env.POLYDEV_USER_TOKEN;
     
@@ -204,7 +250,11 @@ class MCPServer {
         method: 'tools/call',
         params: {
           name: 'get_perspectives',
-          arguments: args
+          arguments: {
+            ...args,
+            prompt: enhancedPrompt,
+            project_memory: enhancedPrompt !== args.prompt ? 'auto-injected' : args.project_memory
+          }
         },
         id: 1
       })
@@ -257,6 +307,13 @@ class MCPServer {
       case 'polydev.send_cli_prompt':
         return this.formatCliPromptResponse(result);
       
+      case 'polydev.detect_memory_sources':
+      case 'polydev.extract_memory':
+      case 'polydev.get_recent_conversations':
+      case 'polydev.get_memory_context':
+      case 'polydev.manage_memory_preferences':
+        return this.formatMemoryResponse(result);
+      
       default:
         return JSON.stringify(result, null, 2);
     }
@@ -536,6 +593,281 @@ class MCPServer {
     }
   }
 
+  /**
+   * Detect available memory sources across CLI tools
+   */
+  async detectMemorySources(args) {
+    console.log('[MCP Server] Detect memory sources requested');
+    
+    try {
+      const { cli_tools = ['all'] } = args;
+      
+      const sources = await this.memoryExtractor.detectMemorySources(cli_tools);
+      
+      return {
+        success: true,
+        sources,
+        message: `Detected ${Object.keys(sources).length} memory sources`,
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      console.error('[MCP Server] Memory detection error:', error);
+      return {
+        success: false,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Extract memory from detected sources
+   */
+  async extractMemory(args) {
+    console.log('[MCP Server] Extract memory requested');
+    
+    try {
+      const { cli_tools = ['all'], memory_types = ['all'], project_path } = args;
+      
+      const extractedMemory = await this.memoryExtractor.extractMemory({
+        cliTools: cli_tools,
+        memoryTypes: memory_types,
+        projectPath: project_path
+      });
+      
+      return {
+        success: true,
+        memory: extractedMemory,
+        message: `Extracted ${extractedMemory.totalEntries} memory entries`,
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      console.error('[MCP Server] Memory extraction error:', error);
+      return {
+        success: false,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Get recent conversations from CLI tools
+   */
+  async getRecentConversations(args) {
+    console.log('[MCP Server] Get recent conversations requested');
+    
+    try {
+      const { cli_tools = ['all'], limit = 10, project_path } = args;
+      
+      const conversations = await this.memoryExtractor.getRecentConversations({
+        cliTools: cli_tools,
+        limit,
+        projectPath: project_path
+      });
+      
+      return {
+        success: true,
+        conversations,
+        message: `Retrieved ${conversations.length} recent conversations`,
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      console.error('[MCP Server] Conversation retrieval error:', error);
+      return {
+        success: false,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Get relevant memory context for current prompt
+   */
+  async getMemoryContext(args) {
+    console.log('[MCP Server] Get memory context requested');
+    
+    try {
+      const { prompt, cli_tools = ['all'], max_entries = 5, project_path } = args;
+      
+      if (!prompt) {
+        throw new Error('prompt is required for context retrieval');
+      }
+      
+      const context = await this.memoryExtractor.getRelevantContext({
+        prompt,
+        cliTools: cli_tools,
+        maxEntries: max_entries,
+        projectPath: project_path
+      });
+      
+      return {
+        success: true,
+        context,
+        message: `Found ${context.entries.length} relevant context entries`,
+        relevanceScore: context.averageRelevance,
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      console.error('[MCP Server] Context retrieval error:', error);
+      return {
+        success: false,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Manage memory preferences and settings
+   */
+  async manageMemoryPreferences(args) {
+    console.log('[MCP Server] Manage memory preferences requested');
+    
+    try {
+      const { action = 'get', preferences = {} } = args;
+      
+      let result;
+      
+      switch (action) {
+        case 'get':
+          result = await this.memoryExtractor.getPreferences();
+          break;
+        
+        case 'set':
+          result = await this.memoryExtractor.updatePreferences(preferences);
+          break;
+        
+        case 'reset':
+          result = await this.memoryExtractor.resetPreferences();
+          break;
+        
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+      
+      return {
+        success: true,
+        preferences: result,
+        message: `Memory preferences ${action} completed`,
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      console.error('[MCP Server] Preferences management error:', error);
+      return {
+        success: false,
+        error: error.message,
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Format memory tool responses
+   */
+  formatMemoryResponse(result) {
+    if (!result.success) {
+      return `❌ Memory Operation Failed: ${result.error}`;
+    }
+
+    let formatted = `# Memory Operation Results\n\n`;
+    formatted += `✅ ${result.message}\n`;
+    formatted += `⏰ ${result.timestamp}\n\n`;
+
+    // Format specific results based on operation type
+    if (result.sources) {
+      formatted += this.formatMemorySourcesResult(result.sources);
+    } else if (result.memory) {
+      formatted += this.formatExtractedMemoryResult(result.memory);
+    } else if (result.conversations) {
+      formatted += this.formatConversationsResult(result.conversations);
+    } else if (result.context) {
+      formatted += this.formatContextResult(result.context, result.relevanceScore);
+    } else if (result.preferences) {
+      formatted += this.formatPreferencesResult(result.preferences);
+    }
+
+    return formatted;
+  }
+
+  formatMemorySourcesResult(sources) {
+    let formatted = `## 📁 Memory Sources Detected\n\n`;
+    
+    Object.entries(sources).forEach(([cliTool, toolSources]) => {
+      formatted += `### ${cliTool.toUpperCase().replace('_', ' ')}\n`;
+      
+      Object.entries(toolSources).forEach(([memoryType, files]) => {
+        const icon = memoryType === 'global' ? '🌍' : memoryType === 'project' ? '📂' : '💬';
+        formatted += `${icon} **${memoryType}**: ${files.length} sources\n`;
+        
+        files.forEach(file => {
+          const status = file.exists ? '✅' : '❌';
+          formatted += `  ${status} \`${file.path}\`\n`;
+        });
+      });
+      
+      formatted += `\n`;
+    });
+    
+    return formatted;
+  }
+
+  formatExtractedMemoryResult(memory) {
+    let formatted = `## 🧠 Extracted Memory\n\n`;
+    formatted += `📊 **Total Entries**: ${memory.totalEntries}\n`;
+    formatted += `💾 **Total Size**: ${(memory.totalSize / 1024).toFixed(1)}KB\n\n`;
+    
+    Object.entries(memory.byCliTool).forEach(([cliTool, toolMemory]) => {
+      formatted += `### ${cliTool.toUpperCase().replace('_', ' ')}\n`;
+      formatted += `- Global: ${toolMemory.global.length} entries\n`;
+      formatted += `- Project: ${toolMemory.project.length} entries\n`;
+      formatted += `- Conversations: ${toolMemory.conversations.length} entries\n\n`;
+    });
+    
+    return formatted;
+  }
+
+  formatConversationsResult(conversations) {
+    let formatted = `## 💬 Recent Conversations\n\n`;
+    
+    conversations.forEach((conv, index) => {
+      formatted += `### ${index + 1}. ${conv.cliTool.toUpperCase().replace('_', ' ')}\n`;
+      formatted += `📅 ${new Date(conv.timestamp).toLocaleString()}\n`;
+      formatted += `💭 ${conv.messageCount} messages, ${(conv.size / 1024).toFixed(1)}KB\n`;
+      
+      if (conv.topics && conv.topics.length > 0) {
+        formatted += `🏷️ Topics: ${conv.topics.join(', ')}\n`;
+      }
+      
+      formatted += `\n`;
+    });
+    
+    return formatted;
+  }
+
+  formatContextResult(context, relevanceScore) {
+    let formatted = `## 🎯 Relevant Context\n\n`;
+    formatted += `📊 **Average Relevance**: ${(relevanceScore * 100).toFixed(1)}%\n\n`;
+    
+    context.entries.forEach((entry, index) => {
+      formatted += `### ${index + 1}. ${entry.source} (${(entry.relevance * 100).toFixed(1)}%)\n`;
+      formatted += `${entry.content.substring(0, 200)}...\n\n`;
+    });
+    
+    return formatted;
+  }
+
+  formatPreferencesResult(preferences) {
+    let formatted = `## ⚙️ Memory Preferences\n\n`;
+    
+    Object.entries(preferences).forEach(([key, value]) => {
+      formatted += `- **${key}**: ${typeof value === 'object' ? JSON.stringify(value) : value}\n`;
+    });
+    
+    return formatted;
+  }
+
   // CLI status and usage tracking is handled locally by CLIManager
   // No database integration needed - this MCP server runs independently
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-ai",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Agentic workflow assistant with CLI integration - get diverse perspectives from multiple LLMs when stuck or need enhanced reasoning",
   "keywords": [
     "mcp",