embark-cli 1.1.7

package/test-roots.mjs

@@ -0,0 +1,306 @@
+#!/usr/bin/env node
+
+/**
+ * Test script for MCP roots/list functionality
+ *
+ * This script spawns the MCP server and tests the roots/list endpoint
+ * by sending JSON-RPC requests via stdio.
+ */
+
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Configuration
+const SERVER_PATH = join(__dirname, 'dist', 'index.js');
+const REPOSITORY_URL = process.env.REPOSITORY_GIT_REMOTE_URL || 'https://github.com/jetbrains/embark-mcp.git';
+
+// 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);
+}
+
+/**
+ * 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);
+            }
+          } catch (e) {
+            // Not valid JSON, continue accumulating
+          }
+        }
+      }
+    };
+
+    server.stdout.on('data', onData);
+
+    // Timeout after 5 seconds
+    setTimeout(() => {
+      if (!resolved) {
+        server.stdout.off('data', onData);
+        reject(new Error('Request timeout'));
+      }
+    }, 5000);
+
+    server.stdin.write(requestStr);
+  });
+}
+
+/**
+ * Test the roots/list endpoint
+ */
+async function testRootsList(server) {
+  log('\n--- Testing roots/list ---', colors.yellow);
+
+  const request = {
+    jsonrpc: '2.0',
+    id: 2,
+    method: 'roots/list',
+  };
+
+  try {
+    const response = await sendRequest(server, request);
+
+    if (response.error) {
+      logError(`Server returned error: ${JSON.stringify(response.error)}`);
+      return false;
+    }
+
+    if (!response.result) {
+      logError('Response missing result field');
+      return false;
+    }
+
+    const { roots } = response.result;
+
+    if (!Array.isArray(roots)) {
+      logError('roots field is not an array');
+      return false;
+    }
+
+    logSuccess('roots/list returned valid response');
+    logInfo(`Found ${roots.length} root(s)`);
+
+    if (roots.length === 0) {
+      log('  No roots configured (this is valid if REPOSITORY_GIT_REMOTE_URL is not set)', colors.yellow);
+      return true;
+    }
+
+    // Validate each root
+    let allValid = true;
+    for (const [index, root] of roots.entries()) {
+      logInfo(`Root ${index + 1}:`);
+
+      if (!root.uri) {
+        logError(`  Missing uri field`);
+        allValid = false;
+        continue;
+      }
+
+      logSuccess(`  uri: ${root.uri}`);
+
+      if (root.name) {
+        logInfo(`  name: ${root.name}`);
+      }
+
+      // Validate URI format (should start with embark:// for this server)
+      if (!root.uri.startsWith('embark://')) {
+        log(`  Warning: URI doesn't start with embark:// (got: ${root.uri})`, colors.yellow);
+      }
+    }
+
+    return allValid;
+  } catch (error) {
+    logError(`Failed to test roots/list: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * 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');
+
+    // Check if server advertises roots capability
+    if (response.result.capabilities?.roots) {
+      logSuccess('Server advertises roots capability');
+      logDebug(`  ${JSON.stringify(response.result.capabilities.roots)}`);
+    } else {
+      logError('Server does not advertise roots capability');
+      return false;
+    }
+
+    return true;
+  } catch (error) {
+    logError(`Failed to initialize: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Main test runner
+ */
+async function runTests() {
+  log('='.repeat(60), colors.blue);
+  log('MCP Server Roots Testing', colors.blue);
+  log('='.repeat(60), colors.blue);
+
+  logInfo(`Server path: ${SERVER_PATH}`);
+  logInfo(`Test repository: ${REPOSITORY_URL}`);
+
+  // Spawn the server
+  log('\n--- Starting MCP server ---', colors.yellow);
+  const server = spawn('node', [SERVER_PATH], {
+    env: {
+      ...process.env,
+      REPOSITORY_GIT_REMOTE_URL: REPOSITORY_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: Roots list
+    if (initSuccess) {
+      const rootsSuccess = await testRootsList(server);
+      if (!rootsSuccess) {
+        allTestsPassed = false;
+        log('\n❌ Roots test failed', colors.red);
+      }
+    }
+
+    // Summary
+    log('\n' + '='.repeat(60), colors.blue);
+    if (allTestsPassed) {
+      log('✓ All tests passed!', 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-snippet-extraction.mjs

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+
+/**
+ * Test script for snippet extraction functionality
+ */
+
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { extractSnippetFromGit } from './dist/git-utils.js';
+
+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',
+};
+
+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);
+}
+
+/**
+ * Test snippet extraction from this repository
+ */
+async function testSnippetExtraction() {
+  log('='.repeat(60), colors.blue);
+  log('Testing Snippet Extraction', colors.blue);
+  log('='.repeat(60), colors.blue);
+
+  const repoPath = __dirname;
+  const testCases = [
+    {
+      name: 'Extract from git-utils.ts',
+      relativePath: 'src/git-utils.ts',
+      revision: 'HEAD',
+      // Extract a reasonable portion from the middle of the file
+      startOffset: 1500,
+      endOffset: 1700,
+      description: 'Extract 200 bytes from git-utils.ts'
+    },
+    {
+      name: 'Extract from package.json',
+      relativePath: 'package.json',
+      revision: null, // Will use HEAD
+      startOffset: 0,
+      endOffset: 100,
+      description: 'Extract first 100 bytes of package.json'
+    },
+    {
+      name: 'Extract beginning of git-utils.ts',
+      relativePath: 'src/git-utils.ts',
+      revision: 'HEAD',
+      startOffset: 0,
+      endOffset: 150,
+      description: 'Extract file header'
+    }
+  ];
+
+  let allTestsPassed = true;
+
+  for (const testCase of testCases) {
+    log(`\n--- ${testCase.name} ---`, colors.yellow);
+    logInfo(testCase.description);
+    logInfo(`File: ${testCase.relativePath}`);
+    logInfo(`Offsets: ${testCase.startOffset}-${testCase.endOffset}`);
+    logInfo(`Revision: ${testCase.revision || 'HEAD'}`);
+
+    try {
+      const snippet = extractSnippetFromGit(
+        repoPath,
+        testCase.relativePath,
+        testCase.revision,
+        testCase.startOffset,
+        testCase.endOffset
+      );
+
+      if (snippet === null) {
+        logError('Failed to extract snippet (returned null)');
+        allTestsPassed = false;
+        continue;
+      }
+
+      if (snippet.length === 0) {
+        logError('Extracted snippet is empty');
+        allTestsPassed = false;
+        continue;
+      }
+
+      logSuccess(`Successfully extracted ${snippet.length} bytes`);
+      log('\nSnippet preview:', colors.gray);
+      log('---', colors.gray);
+      log(snippet.slice(0, 200) + (snippet.length > 200 ? '...' : ''), colors.gray);
+      log('---', colors.gray);
+    } catch (error) {
+      logError(`Test failed with error: ${error.message}`);
+      allTestsPassed = false;
+    }
+  }
+
+  // Summary
+  log('\n' + '='.repeat(60), colors.blue);
+  if (allTestsPassed) {
+    log('✓ All tests passed!', colors.green);
+    log('='.repeat(60), colors.blue);
+    process.exit(0);
+  } else {
+    log('✗ Some tests failed', colors.red);
+    log('='.repeat(60), colors.blue);
+    process.exit(1);
+  }
+}
+
+// Run tests
+testSnippetExtraction().catch((error) => {
+  logError(`Fatal error: ${error.message}`);
+  console.error(error);
+  process.exit(1);
+});

package/watch-logs.sh

@@ -0,0 +1,78 @@
+#!/bin/bash
+
+# Watch logs script for Embark MCP Server
+# This script helps you monitor the server logs in real-time during Claude Code integration testing
+
+LOG_FILE="$HOME/.embark/debug.log"
+
+# Colors
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m' # No Color
+
+echo -e "${BLUE}============================================================${NC}"
+echo -e "${BLUE}Embark MCP Server Log Watcher${NC}"
+echo -e "${BLUE}============================================================${NC}"
+echo ""
+echo -e "${YELLOW}Log file:${NC} $LOG_FILE"
+echo ""
+
+# Check if log file exists
+if [ ! -f "$LOG_FILE" ]; then
+    echo -e "${RED}⚠ Log file does not exist yet.${NC}"
+    echo -e "${YELLOW}ℹ Make sure ENABLE_LOCAL_LOGS=true is set in your .mcp.json${NC}"
+    echo ""
+    echo -e "Example .mcp.json configuration:"
+    echo -e "${BLUE}"
+    cat << 'EOF'
+{
+  "mcpServers": {
+    "embark-mcp": {
+      "command": "node",
+      "args": ["/path/to/embark-remote-mcp/dist/index.js"],
+      "env": {
+        "REPOSITORY_GIT_REMOTE_URL": "https://github.com/your-org/your-repo.git",
+        "ENABLE_LOCAL_LOGS": "true"
+      }
+    }
+  }
+}
+EOF
+    echo -e "${NC}"
+    echo ""
+    echo -e "Waiting for log file to be created..."
+    echo -e "${YELLOW}(Restart Claude Code to create the log file)${NC}"
+    echo ""
+
+    # Wait for file to be created
+    while [ ! -f "$LOG_FILE" ]; do
+        sleep 1
+    done
+
+    echo -e "${GREEN}✓ Log file created!${NC}"
+    echo ""
+fi
+
+echo -e "${GREEN}✓ Watching logs...${NC}"
+echo -e "${YELLOW}ℹ Press Ctrl+C to stop${NC}"
+echo ""
+echo -e "${BLUE}------------------------------------------------------------${NC}"
+echo ""
+
+# Filter and colorize logs
+tail -f "$LOG_FILE" | while IFS= read -r line; do
+    # Check for specific patterns and colorize
+    if echo "$line" | grep -q "ListRoots"; then
+        echo -e "${GREEN}$line${NC}"
+    elif echo "$line" | grep -q '"level": "error"'; then
+        echo -e "${RED}$line${NC}"
+    elif echo "$line" | grep -q '"level": "warn"'; then
+        echo -e "${YELLOW}$line${NC}"
+    elif echo "$line" | grep -q "root"; then
+        echo -e "${BLUE}$line${NC}"
+    else
+        echo "$line"
+    fi
+done