automagik-forge 0.1.11 → 0.1.13

package/scripts/start-mcp-sse.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+const { getPorts } = require('./setup-dev-environment');
+const { loadEnv } = require('./load-env');
+
+async function startMcpSseServer() {
+    try {
+        // Load environment variables
+        loadEnv();
+        
+        // Get allocated ports
+        const ports = await getPorts();
+        
+        // Set environment variables
+        process.env.MCP_SSE_PORT = ports.mcpSse.toString();
+        process.env.FRONTEND_PORT = ports.frontend.toString();
+        process.env.BACKEND_PORT = ports.backend.toString();
+        
+        const mcpBinary = path.join(__dirname, '../target/debug/mcp_task_server');
+        
+        console.log(`Starting MCP SSE server on port ${ports.mcpSse}...`);
+        
+        const mcpProcess = spawn(mcpBinary, ['--mcp-sse'], {
+            stdio: 'pipe',
+            env: { ...process.env }
+        });
+        
+        mcpProcess.stdout.on('data', (data) => {
+            console.log(`[MCP-SSE] ${data.toString().trim()}`);
+        });
+        
+        mcpProcess.stderr.on('data', (data) => {
+            console.error(`[MCP-SSE] ${data.toString().trim()}`);
+        });
+        
+        mcpProcess.on('exit', (code) => {
+            if (code !== 0) {
+                console.warn(`MCP SSE server exited with code ${code}`);
+            } else {
+                console.log('MCP SSE server shutdown gracefully');
+            }
+        });
+        
+        // Handle graceful shutdown
+        process.on('SIGINT', () => {
+            console.log('Shutting down MCP SSE server...');
+            mcpProcess.kill('SIGTERM');
+            setTimeout(() => {
+                mcpProcess.kill('SIGKILL');
+            }, 5000);
+        });
+        
+        process.on('SIGTERM', () => {
+            mcpProcess.kill('SIGTERM');
+        });
+        
+        return mcpProcess;
+    } catch (error) {
+        console.error('Failed to start MCP SSE server:', error);
+        process.exit(1);
+    }
+}
+
+if (require.main === module) {
+    startMcpSseServer();
+}
+
+module.exports = { startMcpSseServer };

package/scripts/test-debug.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+
+console.log('🧪 Debug MCP Server...\n');
+
+const mcpProcess = spawn('cargo', ['run', '--manifest-path', 'backend/Cargo.toml', '--', '--mcp'], {
+  stdio: ['pipe', 'pipe', 'pipe'],
+  env: { ...process.env, PORT: '8894', DISABLE_WORKTREE_ORPHAN_CLEANUP: '1' }
+});
+
+console.log('📤 Sending initialize...');
+mcpProcess.stdin.write('{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "2024-11-05", "capabilities": {}, "clientInfo": {"name": "test", "version": "1.0.0"}}}\n');
+
+mcpProcess.stdout.on('data', (data) => {
+  console.log('📥 STDOUT:', data.toString());
+});
+
+mcpProcess.stderr.on('data', (data) => {
+  console.log('📥 STDERR:', data.toString());
+});
+
+mcpProcess.on('exit', (code) => {
+  console.log(`\n💥 Exit code: ${code}`);
+  process.exit(0);
+});
+
+// Timeout after 5 seconds
+setTimeout(() => {
+  console.log('\n⏰ Timeout - killing process');
+  mcpProcess.kill();
+}, 5000);

package/scripts/test-mcp-sse.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+
+async function testMcpSseIntegration() {
+    console.log('Testing MCP SSE integration...');
+    
+    // Set test environment
+    process.env.MCP_SSE_PORT = '8765';
+    
+const mcpBinary = path.join(__dirname, '../backend/target/debug/automagik-forge-mcp');
+    
+    console.log('Starting MCP SSE server for testing...');
+    const mcpProcess = spawn(mcpBinary, ['--mcp-sse'], {
+        env: { ...process.env }
+    });
+    
+    let serverReady = false;
+    let sseEndpointFound = false;
+    
+    mcpProcess.stdout.on('data', (data) => {
+        const output = data.toString();
+        console.log(`[MCP-SSE] ${output.trim()}`);
+        
+        // Check for SSE server startup message
+        if (output.includes('MCP SSE server listening')) {
+            serverReady = true;
+            sseEndpointFound = true;
+            console.log('✅ SSE server started successfully');
+        }
+        
+        // Check for STDIO server startup
+        if (output.includes('Starting MCP STDIO server')) {
+            console.log('✅ STDIO server started successfully');
+        }
+    });
+    
+    mcpProcess.stderr.on('data', (data) => {
+        const output = data.toString();
+        console.error(`[MCP-SSE ERROR] ${output.trim()}`);
+        
+        // Check for compilation or dependency errors
+        if (output.includes('error:') || output.includes('Error:')) {
+            console.error('❌ MCP server failed to start due to compilation/dependency errors');
+        }
+    });
+    
+    mcpProcess.on('exit', (code) => {
+        if (code !== 0) {
+            console.error(`❌ MCP SSE server exited with code ${code}`);
+        } else {
+            console.log('MCP SSE server exited gracefully');
+        }
+    });
+    
+    // Wait for server startup
+    await new Promise(resolve => {
+        const timeout = setTimeout(() => {
+            console.log('Server startup timeout reached');
+            resolve();
+        }, 10000);
+        
+        const checkReady = setInterval(() => {
+            if (serverReady) {
+                clearTimeout(timeout);
+                clearInterval(checkReady);
+                resolve();
+            }
+        }, 100);
+    });
+    
+    // Test results
+    if (sseEndpointFound) {
+        console.log('✅ MCP SSE server integration test PASSED');
+        console.log('   - SSE server started successfully');
+        console.log('   - Dual transport mode working');
+        console.log('   - Server accessible on http://localhost:8765/sse');
+    } else {
+        console.log('❌ MCP SSE server integration test FAILED');
+        console.log('   - SSE server did not start properly');
+    }
+    
+    // Cleanup
+    console.log('Cleaning up test server...');
+    mcpProcess.kill('SIGTERM');
+    
+    setTimeout(() => {
+        mcpProcess.kill('SIGKILL');
+    }, 2000);
+}
+
+async function testDevWorkflow() {
+    console.log('\nTesting development workflow integration...');
+    
+    // Test port allocation
+    const { getPorts } = require('./setup-dev-environment');
+    
+    try {
+        const ports = await getPorts();
+        console.log('✅ Port allocation working:');
+        console.log(`   - Frontend: ${ports.frontend}`);
+        console.log(`   - Backend: ${ports.backend}`);
+        console.log(`   - MCP SSE: ${ports.mcpSse}`);
+        
+        if (ports.mcpSse) {
+            console.log('✅ MCP SSE port allocation integrated');
+        } else {
+            console.log('❌ MCP SSE port allocation failed');
+        }
+    } catch (error) {
+        console.error('❌ Port allocation test failed:', error.message);
+    }
+}
+
+async function main() {
+    console.log('🧪 Running MCP SSE Integration Tests\n');
+    
+    // Test 1: SSE server functionality
+    await testMcpSseIntegration();
+    
+    // Test 2: Development workflow integration
+    await testDevWorkflow();
+    
+    console.log('\n🎯 Test Summary:');
+    console.log('Run these commands to verify full integration:');
+    console.log('  1. pnpm run mcp:build    # Build MCP binary');
+    console.log('  2. pnpm run dev          # Start full dev environment');
+    console.log('  3. curl http://localhost:$(node scripts/setup-dev-environment.js | jq -r .mcpSse)/sse');
+    console.log('');
+    console.log('Expected: SSE connection established with MCP server');
+}
+
+if (require.main === module) {
+    main().catch(console.error);
+}
+
+module.exports = { testMcpSseIntegration, testDevWorkflow };

package/scripts/test-simple.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+
+console.log('🧪 Simple MCP Test...\n');
+
+// Start MCP server
+const mcpProcess = spawn('cargo', ['run', '--manifest-path', 'backend/Cargo.toml', '--', '--mcp'], {
+  stdio: ['pipe', 'pipe', 'inherit'],
+  env: { ...process.env, PORT: '8892', DISABLE_WORKTREE_ORPHAN_CLEANUP: '1' }
+});
+
+let responseCount = 0;
+
+mcpProcess.stdout.on('data', (data) => {
+  const response = data.toString().trim();
+  console.log(`📥 Response ${++responseCount}:`, response);
+  
+  if (responseCount === 1) {
+    // Send initialize after first response
+    console.log('📤 Sending initialize...');
+    mcpProcess.stdin.write(`{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "2024-11-05", "capabilities": {}, "clientInfo": {"name": "test", "version": "1.0.0"}}}\n`);
+  } else if (responseCount === 2) {
+    // Send list_tools after initialize response
+    console.log('📤 Sending list_tools...');
+    mcpProcess.stdin.write(`{"jsonrpc": "2.0", "id": 2, "method": "tools/list", "params": {}}\n`);
+  } else if (responseCount === 3) {
+    console.log('✅ Test successful - MCP server responding');
+    mcpProcess.kill();
+    process.exit(0);
+  }
+});
+
+mcpProcess.on('exit', (code) => {
+  console.log(`\n🔴 MCP server exited with code: ${code}`);
+  process.exit(0);
+});
+
+// Safety timeout
+setTimeout(() => {
+  console.log('\n⏰ Test timeout');
+  mcpProcess.kill();
+  process.exit(1);
+}, 10000);

package/scripts/test-wish-final.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+
+console.log('🧪 Testing Wish System - Final Test...\n');
+
+let messageId = 1;
+let testData = {
+  projectId: null,
+  taskId1: null,
+  taskId2: null,
+  wishId: 'test-refactor-auth'
+};
+
+function send(mcpProcess, message) {
+  const jsonStr = JSON.stringify(message);
+  console.log('📤 SEND:', jsonStr);
+  mcpProcess.stdin.write(jsonStr + '\n');
+}
+
+function testCreateTasks(mcpProcess) {
+  console.log('\n=== Testing Task Creation with wish_id ===');
+  
+  // Get existing projects first
+  send(mcpProcess, {
+    "jsonrpc": "2.0",
+    "id": messageId++,
+    "method": "tools/call",
+    "params": {
+      "name": "list_projects",
+      "arguments": {}
+    }
+  });
+}
+
+const mcpProcess = spawn('cargo', ['run', '--manifest-path', 'backend/Cargo.toml', '--', '--mcp'], {
+  stdio: ['pipe', 'pipe', 'inherit'],
+  env: { ...process.env, PORT: '8893', DISABLE_WORKTREE_ORPHAN_CLEANUP: '1' }
+});
+
+let step = 0;
+let responses = [];
+
+mcpProcess.stdout.on('data', (data) => {
+  const response = data.toString().trim();
+  
+  // Skip log lines, only process JSON responses
+  if (!response.startsWith('{')) {
+    return;
+  }
+  
+  console.log(`📥 RECV:`, response);
+  responses.push(response);
+  
+  try {
+    const parsed = JSON.parse(response);
+    
+    if (step === 0) {
+      // Initialize
+      send(mcpProcess, {
+        "jsonrpc": "2.0",
+        "id": messageId++,
+        "method": "initialize",
+        "params": {
+          "protocolVersion": "2024-11-05",
+          "capabilities": {},
+          "clientInfo": {"name": "wish-test", "version": "1.0.0"}
+        }
+      });
+      step++;
+    } else if (step === 1) {
+      // After initialize, get projects
+      testCreateTasks(mcpProcess);
+      step++;
+    } else if (step === 2 && parsed.result?.content) {
+      // Parse project list response
+      const content = JSON.parse(parsed.result.content[0].text);
+      if (content.projects && content.projects.length > 0) {
+        testData.projectId = content.projects[0].id;
+        console.log(`💾 Using project: ${testData.projectId}`);
+        
+        // Create first task with wish_id
+        send(mcpProcess, {
+          "jsonrpc": "2.0",
+          "id": messageId++,
+          "method": "tools/call",
+          "params": {
+            "name": "create_task",
+            "arguments": {
+              "project_id": testData.projectId,
+              "title": "First task in wish",
+              "description": "Testing wish system - first task",
+              "wish_id": testData.wishId
+            }
+          }
+        });
+        step++;
+      }
+    } else if (step === 3 && parsed.result?.content) {
+      // Parse first task creation response
+      const content = JSON.parse(parsed.result.content[0].text);
+      if (content.task_id) {
+        testData.taskId1 = content.task_id;
+        console.log(`💾 First task created: ${testData.taskId1}`);
+        
+        // Create second task with same wish_id (should succeed for grouping)
+        send(mcpProcess, {
+          "jsonrpc": "2.0",
+          "id": messageId++,
+          "method": "tools/call",
+          "params": {
+            "name": "create_task",
+            "arguments": {
+              "project_id": testData.projectId,
+              "title": "Second task in same wish",
+              "description": "Testing wish system - second task in same wish",
+              "wish_id": testData.wishId
+            }
+          }
+        });
+        step++;
+      }
+    } else if (step === 4 && parsed.result?.content) {
+      // Parse second task creation response
+      const content = JSON.parse(parsed.result.content[0].text);
+      if (content.task_id) {
+        testData.taskId2 = content.task_id;
+        console.log(`💾 Second task created: ${testData.taskId2}`);
+        
+        // List tasks filtered by wish_id
+        send(mcpProcess, {
+          "jsonrpc": "2.0",
+          "id": messageId++,
+          "method": "tools/call",
+          "params": {
+            "name": "list_tasks",
+            "arguments": {
+              "project_id": testData.projectId,
+              "wish_id": testData.wishId
+            }
+          }
+        });
+        step++;
+      }
+    } else if (step === 5 && parsed.result?.content) {
+      // Parse list tasks response
+      const content = JSON.parse(parsed.result.content[0].text);
+      console.log(`✅ Found ${content.count} tasks with wish_id '${testData.wishId}'`);
+      
+      if (content.count === 2) {
+        console.log('\n🎉 WISH SYSTEM TEST SUCCESSFUL!');
+        console.log('   ✅ Created multiple tasks with same wish_id');
+        console.log('   ✅ Tasks grouped properly by wish_id');
+        console.log('   ✅ Filtering by wish_id works correctly');
+      } else {
+        console.log(`❌ Expected 2 tasks, got ${content.count}`);
+      }
+      
+      setTimeout(() => {
+        mcpProcess.kill();
+        process.exit(0);
+      }, 500);
+    }
+  } catch (e) {
+    console.log('⚠️ Non-JSON response or parsing error:', e.message);
+  }
+});
+
+mcpProcess.on('exit', (code) => {
+  console.log(`\n🔴 MCP server exited with code: ${code}`);
+  process.exit(0);
+});
+
+// Safety timeout
+setTimeout(() => {
+  console.log('\n⏰ Test timeout');
+  mcpProcess.kill();
+  process.exit(1);
+}, 20000);

package/scripts/test-wish-system.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+
+console.log('🧪 Testing Wish System Implementation...\n');
+
+let messageId = 1;
+let testData = {
+  projectId: null,
+  taskId1: null,
+  taskId2: null,
+  wishId: 'test-refactor-auth',
+  duplicateWishId: 'test-refactor-auth', // Same wish - should fail
+  differentWishId: 'test-feature-dashboard'
+};
+
+const testSequence = [
+  'initialize',
+  'initialized_notification', 
+  'list_tools',
+  'list_projects',
+  'create_task_with_wish',
+  'create_task_same_wish', // Should succeed - same wish, different task (grouping)
+  'list_tasks_by_wish',
+  'update_task_wish',
+  'test_summary'
+];
+
+let currentStep = 0;
+
+const steps = {
+  initialize: () => {
+    console.log('📤 Initializing MCP connection...');
+    send({"jsonrpc": "2.0", "id": messageId++, "method": "initialize", "params": {"protocolVersion": "2024-11-05", "capabilities": {}, "clientInfo": {"name": "wish-test", "version": "1.0.0"}}});
+  },
+
+  initialized_notification: () => {
+    console.log('📤 Sending initialized notification...');
+    send({"jsonrpc": "2.0", "method": "notifications/initialized"});
+    setTimeout(nextStep, 200);
+  },
+
+  list_tools: () => {
+    console.log('📤 Listing available tools...');
+    send({"jsonrpc": "2.0", "id": messageId++, "method": "tools/list", "params": {}});
+  },
+
+  list_projects: () => {
+    console.log('📤 Getting existing projects...');
+    send({"jsonrpc": "2.0", "id": messageId++, "method": "tools/call", "params": {"name": "list_projects", "arguments": {}}});
+  },
+
+  create_task_with_wish: () => {
+    console.log('📤 Creating task with wish_id (should succeed)...');
+    send({
+      "jsonrpc": "2.0", 
+      "id": messageId++, 
+      "method": "tools/call", 
+      "params": {
+        "name": "create_task", 
+        "arguments": {
+          "project_id": testData.projectId,
+          "title": "First task in wish",
+          "description": "Testing wish system - first task",
+          "wish_id": testData.wishId
+        }
+      }
+    });
+  },
+
+  create_task_same_wish: () => {
+    console.log('📤 Creating another task with same wish_id (should succeed)...');
+    send({
+      "jsonrpc": "2.0", 
+      "id": messageId++, 
+      "method": "tools/call", 
+      "params": {
+        "name": "create_task", 
+        "arguments": {
+          "project_id": testData.projectId,
+          "title": "Second task in same wish",
+          "description": "Testing wish system - second task in same wish",
+          "wish_id": testData.wishId
+        }
+      }
+    });
+  },
+
+
+  list_tasks_by_wish: () => {
+    console.log('📤 Listing tasks filtered by wish_id...');
+    send({
+      "jsonrpc": "2.0", 
+      "id": messageId++, 
+      "method": "tools/call", 
+      "params": {
+        "name": "list_tasks", 
+        "arguments": {
+          "project_id": testData.projectId,
+          "wish_id": testData.wishId
+        }
+      }
+    });
+  },
+
+  update_task_wish: () => {
+    console.log('📤 Updating task wish_id...');
+    send({
+      "jsonrpc": "2.0", 
+      "id": messageId++, 
+      "method": "tools/call", 
+      "params": {
+        "name": "update_task", 
+        "arguments": {
+          "task_id": testData.taskId2,
+          "wish_id": testData.differentWishId
+        }
+      }
+    });
+  },
+
+  test_summary: () => {
+    console.log('\n✅ Wish System Test Complete!');
+    console.log('\n📊 Test Results:');
+    console.log(`   ✅ Created tasks with wish_id: ${testData.wishId}`);
+    console.log(`   ✅ Multiple tasks can share same wish_id (grouping)`);
+    console.log(`   ✅ Filtered tasks by wish_id successfully`);
+    console.log(`   ✅ Updated task wish_id successfully`);
+    console.log('\n🎉 All wish system features working correctly!');
+    
+    setTimeout(() => {
+      mcpProcess.kill();
+      process.exit(0);
+    }, 500);
+  }
+};
+
+function send(message) {
+  mcpProcess.stdin.write(JSON.stringify(message) + '\n');
+}
+
+function nextStep() {
+  currentStep++;
+  if (currentStep < testSequence.length) {
+    executeStep();
+  }
+}
+
+function executeStep() {
+  const stepName = testSequence[currentStep];
+  console.log(`\n🔄 Step ${currentStep + 1}/${testSequence.length}: ${stepName}`);
+  
+  setTimeout(() => {
+    steps[stepName]();
+  }, 100);
+}
+
+// Start MCP server
+const mcpProcess = spawn('cargo', ['run', '--manifest-path', 'backend/Cargo.toml', '--', '--mcp'], {
+  stdio: ['pipe', 'pipe', 'inherit'],
+  env: { ...process.env, PORT: '8890', DISABLE_WORKTREE_ORPHAN_CLEANUP: '1' }
+});
+
+mcpProcess.stdout.on('data', (data) => {
+  const response = data.toString().trim();
+  console.log(`📥 Response:`, response);
+  
+  try {
+    const parsed = JSON.parse(response);
+    
+    // Extract useful data from responses
+    if (parsed.result?.content) {
+      const content = JSON.parse(parsed.result.content[0].text);
+      
+      // Get project ID from list_projects
+      if (content.projects && content.projects.length > 0) {
+        testData.projectId = content.projects[0].id;
+        console.log(`💾 Using project: ${testData.projectId}`);
+      }
+      
+      // Get task IDs from create_task responses
+      if (content.task_id) {
+        if (!testData.taskId1) {
+          testData.taskId1 = content.task_id;
+          console.log(`💾 First task: ${testData.taskId1}`);
+        } else if (!testData.taskId2) {
+          testData.taskId2 = content.task_id;
+          console.log(`💾 Second task: ${testData.taskId2}`);
+        }
+      }
+      
+    }
+    
+    nextStep();
+  } catch (e) {
+    // If not JSON, still continue
+    nextStep();
+  }
+});
+
+mcpProcess.on('exit', (code) => {
+  console.log(`\n🔴 MCP server exited with code: ${code}`);
+  process.exit(0);
+});
+
+mcpProcess.on('error', (error) => {
+  console.error('❌ MCP server error:', error);
+  process.exit(1);
+});
+
+// Start test sequence
+setTimeout(() => {
+  executeStep();
+}, 1000);
+
+// Safety timeout
+setTimeout(() => {
+  console.log('\n⏰ Test timeout - killing process');
+  mcpProcess.kill();
+  process.exit(1);
+}, 30000);