embark-cli 1.1.7

package/test-git-discovery.mjs

@@ -0,0 +1,322 @@
+#!/usr/bin/env node
+
+/**
+ * Test script for Git repository discovery from roots
+ *
+ * This script tests that the server can:
+ * 1. Accept roots from a client (simulated)
+ * 2. Discover Git remote URLs from those directories
+ * 3. Use the discovered URLs for searches
+ */
+
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { execSync } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Configuration
+const SERVER_PATH = join(__dirname, 'dist', 'index.js');
+const TEST_ROOT = process.cwd(); // Use current directory as test root
+
+// Colors for terminal output
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  gray: '\x1b[90m',
+};
+
+function log(message, color = colors.reset) {
+  console.log(`${color}${message}${colors.reset}`);
+}
+
+function logSuccess(message) {
+  log(`✓ ${message}`, colors.green);
+}
+
+function logError(message) {
+  log(`✗ ${message}`, colors.red);
+}
+
+function logInfo(message) {
+  log(`ℹ ${message}`, colors.blue);
+}
+
+function logDebug(message) {
+  log(`  ${message}`, colors.gray);
+}
+
+/**
+ * Get Git remote URL from current directory
+ */
+function getLocalGitRemote() {
+  try {
+    const result = execSync('git remote get-url origin', {
+      cwd: TEST_ROOT,
+      encoding: 'utf-8',
+    });
+    return result.trim();
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Send a JSON-RPC request to the server
+ */
+function sendRequest(server, request) {
+  return new Promise((resolve, reject) => {
+    const requestStr = JSON.stringify(request) + '\n';
+    logDebug(`→ ${requestStr.trim()}`);
+
+    let responseBuffer = '';
+    let resolved = false;
+
+    const onData = (data) => {
+      responseBuffer += data.toString();
+
+      // Try to parse complete JSON objects
+      const lines = responseBuffer.split('\n');
+      responseBuffer = lines.pop(); // Keep incomplete line in buffer
+
+      for (const line of lines) {
+        if (line.trim()) {
+          try {
+            const response = JSON.parse(line);
+            logDebug(`← ${line}`);
+
+            // Check if this is the response to our request
+            if (response.id === request.id) {
+              resolved = true;
+              server.stdout.off('data', onData);
+              resolve(response);
+            } else if (response.method === 'roots/list') {
+              // Server is requesting roots from us
+              logInfo('Server requested roots from client');
+              const rootsResponse = {
+                jsonrpc: '2.0',
+                id: response.id,
+                result: {
+                  roots: [
+                    {
+                      uri: `file://${TEST_ROOT}`,
+                      name: 'Test Project'
+                    }
+                  ]
+                }
+              };
+              const responseStr = JSON.stringify(rootsResponse) + '\n';
+              logDebug(`→ ${responseStr.trim()}`);
+              server.stdin.write(responseStr);
+            }
+          } catch (e) {
+            // Not valid JSON, continue accumulating
+          }
+        }
+      }
+    };
+
+    server.stdout.on('data', onData);
+
+    // Timeout after 10 seconds
+    setTimeout(() => {
+      if (!resolved) {
+        server.stdout.off('data', onData);
+        reject(new Error('Request timeout'));
+      }
+    }, 10000);
+
+    server.stdin.write(requestStr);
+  });
+}
+
+/**
+ * Test server initialization
+ */
+async function testInitialize(server) {
+  log('\n--- Testing initialization ---', colors.yellow);
+
+  const request = {
+    jsonrpc: '2.0',
+    id: 1,
+    method: 'initialize',
+    params: {
+      protocolVersion: '2024-11-05',
+      capabilities: {
+        roots: {
+          listChanged: true,
+        },
+      },
+      clientInfo: {
+        name: 'test-client',
+        version: '1.0.0',
+      },
+    },
+  };
+
+  try {
+    const response = await sendRequest(server, request);
+
+    if (response.error) {
+      logError(`Initialization error: ${JSON.stringify(response.error)}`);
+      return false;
+    }
+
+    if (!response.result) {
+      logError('Initialization response missing result');
+      return false;
+    }
+
+    logSuccess('Server initialized successfully');
+    return true;
+  } catch (error) {
+    logError(`Failed to initialize: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Test that Git discovery works by making a search
+ */
+async function testGitDiscovery(server, expectedGitUrl) {
+  log('\n--- Testing Git repository discovery ---', colors.yellow);
+
+  // Wait a bit for the server to process roots
+  await new Promise(resolve => setTimeout(resolve, 1000));
+
+  // Make a search request without specifying repository
+  const request = {
+    jsonrpc: '2.0',
+    id: 3,
+    method: 'tools/call',
+    params: {
+      name: 'semantic_code_search',
+      arguments: {
+        text: 'test search query',
+      }
+    }
+  };
+
+  try {
+    const response = await sendRequest(server, request);
+
+    if (response.error) {
+      logError(`Search error: ${JSON.stringify(response.error)}`);
+      return false;
+    }
+
+    const content = response.result?.content?.[0]?.text || '';
+
+    // Check if the response indicates the discovered repository was used
+    if (content.includes(expectedGitUrl) || !content.includes('No repository URL configured')) {
+      logSuccess('Git repository was discovered and used for search');
+      logInfo(`Repository: ${expectedGitUrl}`);
+      return true;
+    } else {
+      logError('Search did not use discovered Git repository');
+      logDebug(`Response: ${content}`);
+      return false;
+    }
+  } catch (error) {
+    logError(`Failed to test Git discovery: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Main test runner
+ */
+async function runTests() {
+  log('='.repeat(60), colors.blue);
+  log('MCP Server Git Discovery Testing', colors.blue);
+  log('='.repeat(60), colors.blue);
+
+  logInfo(`Server path: ${SERVER_PATH}`);
+  logInfo(`Test root: ${TEST_ROOT}`);
+
+  // Check if current directory is a Git repository
+  const gitRemote = getLocalGitRemote();
+  if (!gitRemote) {
+    logError('Current directory is not a Git repository or has no remote');
+    log('Please run this test from a Git repository with a configured remote', colors.yellow);
+    process.exit(1);
+  }
+
+  logInfo(`Expected Git remote: ${gitRemote}`);
+
+  // Spawn the server (without REPOSITORY_GIT_REMOTE_URL env var)
+  log('\n--- Starting MCP server ---', colors.yellow);
+  const server = spawn('node', [SERVER_PATH], {
+    env: {
+      ...process.env,
+      ENABLE_LOCAL_LOGS: 'true',
+      // Intentionally NOT setting REPOSITORY_GIT_REMOTE_URL
+    },
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+
+  // Log stderr for debugging
+  server.stderr.on('data', (data) => {
+    logDebug(`[stderr] ${data.toString().trim()}`);
+  });
+
+  server.on('error', (error) => {
+    logError(`Failed to start server: ${error.message}`);
+    process.exit(1);
+  });
+
+  // Wait a bit for server to start
+  await new Promise(resolve => setTimeout(resolve, 500));
+
+  let allTestsPassed = true;
+
+  try {
+    // Test 1: Initialize
+    const initSuccess = await testInitialize(server);
+    if (!initSuccess) {
+      allTestsPassed = false;
+      log('\n❌ Initialization test failed', colors.red);
+    }
+
+    // Test 2: Git discovery
+    if (initSuccess) {
+      const discoverySuccess = await testGitDiscovery(server, gitRemote);
+      if (!discoverySuccess) {
+        allTestsPassed = false;
+        log('\n❌ Git discovery test failed', colors.red);
+      }
+    }
+
+    // Summary
+    log('\n' + '='.repeat(60), colors.blue);
+    if (allTestsPassed) {
+      log('✓ All tests passed!', colors.green);
+      log('✓ Server successfully discovered Git repository from roots', colors.green);
+      log('='.repeat(60), colors.blue);
+      server.kill();
+      process.exit(0);
+    } else {
+      log('✗ Some tests failed', colors.red);
+      log('='.repeat(60), colors.blue);
+      server.kill();
+      process.exit(1);
+    }
+  } catch (error) {
+    logError(`Test execution failed: ${error.message}`);
+    console.error(error);
+    server.kill();
+    process.exit(1);
+  }
+}
+
+// Run tests
+runTests().catch((error) => {
+  logError(`Fatal error: ${error.message}`);
+  console.error(error);
+  process.exit(1);
+});

package/test-multi-repo-filters.mjs

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+
+/**
+ * Test script for multi-repository filtering with environment variables
+ *
+ * This script tests the INCLUDE_REPOSITORY_URLS and EXCLUDE_REPOSITORY_URLS
+ * environment variable functionality.
+ */
+
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Colors for terminal output
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  gray: '\x1b[90m',
+  cyan: '\x1b[36m',
+};
+
+function log(message, color = colors.reset) {
+  console.log(`${color}${message}${colors.reset}`);
+}
+
+function logSuccess(message) {
+  log(`✓ ${message}`, colors.green);
+}
+
+function logInfo(message) {
+  log(`ℹ ${message}`, colors.blue);
+}
+
+function logSection(message) {
+  log(`\n${'='.repeat(60)}`, colors.cyan);
+  log(message, colors.cyan);
+  log('='.repeat(60), colors.cyan);
+}
+
+/**
+ * Main test runner
+ */
+async function runTests() {
+  log('='.repeat(60), colors.blue);
+  log('Multi-Repository Filter Testing', colors.blue);
+  log('='.repeat(60), colors.blue);
+
+  logInfo('This test demonstrates the multi-repository search functionality');
+  logInfo('with INCLUDE_REPOSITORY_URLS and EXCLUDE_REPOSITORY_URLS environment variables\n');
+
+  // Test scenarios
+  const scenarios = [
+    {
+      name: 'No filters (search all discovered repositories)',
+      env: {},
+      description: 'When no filter env vars are set, all discovered repositories are searched',
+    },
+    {
+      name: 'Include additions (add specific repositories to search)',
+      env: {
+        INCLUDE_REPOSITORY_URLS: 'https://github.com/owner/repo1.git,https://github.com/owner/repo2.git'
+      },
+      description: 'Discovered repositories plus the ones in INCLUDE_REPOSITORY_URLS are searched',
+    },
+    {
+      name: 'Exclude filter (skip specified repositories)',
+      env: {
+        EXCLUDE_REPOSITORY_URLS: 'https://github.com/owner/large-repo.git'
+      },
+      description: 'All repositories except those in EXCLUDE_REPOSITORY_URLS are searched',
+    },
+    {
+      name: 'Both filters (include then exclude)',
+      env: {
+        INCLUDE_REPOSITORY_URLS: 'https://github.com/owner/repo1.git,https://github.com/owner/repo2.git,https://github.com/owner/repo3.git',
+        EXCLUDE_REPOSITORY_URLS: 'https://github.com/owner/repo3.git'
+      },
+      description: 'Repositories from INCLUDE_REPOSITORY_URLS are added, then anything in EXCLUDE_REPOSITORY_URLS is removed',
+    },
+  ];
+
+  scenarios.forEach((scenario, index) => {
+    logSection(`Scenario ${index + 1}: ${scenario.name}`);
+    logInfo(scenario.description);
+
+    if (Object.keys(scenario.env).length === 0) {
+      log('\n  No environment variables set', colors.gray);
+    } else {
+      log('\n  Environment variables:', colors.gray);
+      Object.entries(scenario.env).forEach(([key, value]) => {
+        log(`    ${key}=${value}`, colors.gray);
+      });
+    }
+
+    log('\n  To test this scenario, run:', colors.yellow);
+    const envVars = Object.entries(scenario.env)
+      .map(([key, value]) => `${key}="${value}"`)
+      .join(' ');
+    const command = envVars
+      ? `  ${envVars} node dist/index.js`
+      : `  node dist/index.js`;
+    log(command, colors.yellow);
+  });
+
+  logSection('Implementation Details');
+
+  logInfo('How it works:');
+  log('  1. Server discovers all Git repositories from workspace roots', colors.gray);
+  log('  2. Before each search, repositories are adjusted based on env vars:', colors.gray);
+  log('     - If INCLUDE_REPOSITORY_URLS is set: those repos are added to the list', colors.gray);
+  log('     - If EXCLUDE_REPOSITORY_URLS is set: those repos are removed', colors.gray);
+  log('  3. If multiple repos remain after filtering: multi-repo search', colors.gray);
+  log('  4. If only one repo remains: single-repo search (cleaner output)', colors.gray);
+  log('  5. If no repos remain: error message', colors.gray);
+
+  logSection('Configuration Format');
+
+  log('  INCLUDE_REPOSITORY_URLS: Comma-separated list of Git URLs to include', colors.gray);
+  log('    Example: export INCLUDE_REPOSITORY_URLS="https://github.com/owner/repo1.git,https://github.com/owner/repo2.git"', colors.gray);
+
+  log('\n  EXCLUDE_REPOSITORY_URLS: Comma-separated list of Git URLs to exclude', colors.gray);
+  log('    Example: export EXCLUDE_REPOSITORY_URLS="https://github.com/owner/large-repo.git"', colors.gray);
+
+  logSection('Backward Compatibility');
+
+  log('  ✓ Existing single-repository setups continue to work', colors.green);
+  log('  ✓ REPOSITORY_GIT_REMOTE_URL env var still supported as fallback', colors.green);
+  log('  ✓ No breaking changes to existing tool parameters', colors.green);
+
+  logSection('Summary');
+
+  logSuccess('Multi-repository search is now implemented!');
+  log('  • By default: searches all discovered repositories', colors.gray);
+  log('  • With INCLUDE_REPOSITORY_URLS: searches discovered repos plus specified URLs', colors.gray);
+  log('  • With EXCLUDE_REPOSITORY_URLS: searches all except specified repos', colors.gray);
+  log('  • Results are aggregated with clear repository labels', colors.gray);
+  log('  • Parallel search execution for better performance', colors.gray);
+
+  log('\n');
+}
+
+// Run tests
+runTests().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});