stringray-ai 1.0.0

package/scripts/validation/validate-external-processes.js

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+
+/**
+ * External Process Communication Validator
+ *
+ * Tests StringRay's ability to spawn and communicate with external processes
+ * Validates the orchestration system's external integration capabilities
+ */
+
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+class ExternalProcessValidator {
+  constructor() {
+    this.results = { passed: [], failed: [] };
+  }
+
+  async validateExternalCommunication() {
+    console.log('🔄 EXTERNAL PROCESS COMMUNICATION VALIDATOR');
+    console.log('============================================');
+
+    const tests = [
+      this.validateProcessSpawning.bind(this),
+      this.validateInterProcessCommunication.bind(this),
+      this.validateResourceCleanup.bind(this),
+      this.validateErrorHandling.bind(this)
+    ];
+
+    for (const test of tests) {
+      await test();
+    }
+
+    this.printSummary();
+    return this.results.failed.length === 0;
+  }
+
+  async validateProcessSpawning() {
+    console.log('\n🚀 Testing Process Spawning...');
+
+    return new Promise((resolve) => {
+      // Test spawning a simple MCP server process
+      const serverPath = path.join(process.cwd(), 'dist/mcps/enhanced-orchestrator.server.js');
+
+      if (!fs.existsSync(serverPath)) {
+        console.log('  ❌ Server file not found');
+        this.results.failed.push({ test: 'Process Spawning', error: 'Server file missing' });
+        resolve();
+        return;
+      }
+
+      const child = spawn('node', [serverPath], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 8000
+      });
+
+      let started = false;
+
+      child.stdout.on('data', (data) => {
+        if (data.toString().includes('MCP Server') && !started) {
+          started = true;
+          console.log('  ✅ Process spawned successfully');
+        }
+      });
+
+      child.on('close', (code) => {
+        if (started) {
+          this.results.passed.push('Process Spawning');
+        } else {
+          this.results.failed.push({ test: 'Process Spawning', error: `Exit code ${code}` });
+        }
+        resolve();
+      });
+
+      child.on('error', (error) => {
+        this.results.failed.push({ test: 'Process Spawning', error: error.message });
+        resolve();
+      });
+
+      // Clean up after 3 seconds
+      setTimeout(() => {
+        child.kill();
+        if (!started) {
+          this.results.failed.push({ test: 'Process Spawning', error: 'Process failed to start' });
+        }
+        resolve();
+      }, 3000);
+    });
+  }
+
+  async validateInterProcessCommunication() {
+    console.log('\n💬 Testing Inter-Process Communication...');
+
+    return new Promise((resolve) => {
+      // Test MCP protocol communication
+      const serverPath = path.join(process.cwd(), 'dist/mcps/enhanced-orchestrator.server.js');
+
+      const child = spawn('node', [serverPath], {
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+
+      let responseReceived = false;
+
+      child.stdout.on('data', (data) => {
+        const output = data.toString();
+        if (output.includes('initialized') || output.includes('running')) {
+          responseReceived = true;
+        }
+      });
+
+      // Send a test message after 1 second
+      setTimeout(() => {
+        if (responseReceived) {
+          console.log('  ✅ Inter-process communication working');
+          this.results.passed.push('Inter-Process Communication');
+        } else {
+          console.log('  ❌ No response from spawned process');
+          this.results.failed.push({ test: 'Inter-Process Communication', error: 'No response received' });
+        }
+        child.kill();
+        resolve();
+      }, 2000);
+
+      child.on('error', (error) => {
+        this.results.failed.push({ test: 'Inter-Process Communication', error: error.message });
+        resolve();
+      });
+    });
+  }
+
+  async validateResourceCleanup() {
+    console.log('\n🧹 Testing Resource Cleanup...');
+
+    return new Promise((resolve) => {
+      const processes = [];
+
+      // Spawn multiple processes
+      for (let i = 0; i < 3; i++) {
+        const child = spawn('node', ['-e', 'setInterval(() => {}, 1000)'], {
+          stdio: 'ignore'
+        });
+        processes.push(child);
+      }
+
+      // Wait a moment then kill them
+      setTimeout(() => {
+        let cleanedUp = 0;
+        processes.forEach(child => {
+          child.on('close', () => {
+            cleanedUp++;
+            if (cleanedUp === processes.length) {
+              console.log('  ✅ Resource cleanup working');
+              this.results.passed.push('Resource Cleanup');
+              resolve();
+            }
+          });
+          child.kill();
+        });
+
+        // Timeout if cleanup takes too long
+        setTimeout(() => {
+          if (cleanedUp < processes.length) {
+            console.log('  ❌ Resource cleanup timeout');
+            this.results.failed.push({ test: 'Resource Cleanup', error: 'Cleanup timeout' });
+            resolve();
+          }
+        }, 1000);
+      }, 500);
+    });
+  }
+
+  async validateErrorHandling() {
+    console.log('\n🚨 Testing Error Handling...');
+
+    return new Promise((resolve) => {
+      // Test spawning a non-existent process
+      const child = spawn('nonexistentcommand', [], {
+        stdio: 'pipe'
+      });
+
+      let errorHandled = false;
+
+      child.on('error', (error) => {
+        if (error.code === 'ENOENT') {
+          errorHandled = true;
+          console.log('  ✅ Error handling working correctly');
+          this.results.passed.push('Error Handling');
+        }
+      });
+
+      child.on('close', (code) => {
+        if (!errorHandled) {
+          console.log('  ❌ Error not handled properly');
+          this.results.failed.push({ test: 'Error Handling', error: 'Error not caught' });
+        }
+        resolve();
+      });
+
+      // Timeout
+      setTimeout(() => {
+        if (!errorHandled) {
+          console.log('  ❌ Error handling timeout');
+          this.results.failed.push({ test: 'Error Handling', error: 'Timeout' });
+        }
+        resolve();
+      }, 1000);
+    });
+  }
+
+  printSummary() {
+    console.log('\n📊 EXTERNAL PROCESS VALIDATION SUMMARY');
+    console.log('======================================');
+
+    console.log(`✅ Passed: ${this.results.passed.length}`);
+    console.log(`❌ Failed: ${this.results.failed.length}`);
+
+    if (this.results.failed.length > 0) {
+      console.log('\n❌ FAILED TESTS:');
+      this.results.failed.forEach(failure => {
+        console.log(`  • ${failure.test}: ${failure.error}`);
+      });
+    }
+
+    if (this.results.passed.length > 0) {
+      console.log('\n✅ PASSED TESTS:');
+      this.results.passed.forEach(test => {
+        console.log(`  • ${test}`);
+      });
+    }
+  }
+}
+
+// Run external process validation
+const validator = new ExternalProcessValidator();
+validator.validateExternalCommunication().then(success => {
+  process.exit(success ? 0 : 1);
+}).catch(error => {
+  console.error('External process validation failed:', error);
+  process.exit(1);
+});

package/scripts/validation/validate-mcp-connectivity.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+
+/**
+ * MCP Server Connectivity Validator
+ *
+ * Tests all StringRay MCP servers for proper startup and protocol compliance
+ * Validates external integration points that internal tests miss
+ */
+
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+const MCP_SERVERS = [
+  { name: 'librarian', path: 'dist/mcps/knowledge-skills/project-analysis.server.js' },
+  { name: 'session-management', path: '.opencode/mcps/session-management.server.js' },
+  { name: 'orchestrator', path: 'dist/mcps/orchestrator.server.js' },
+  { name: 'enhanced-orchestrator', path: 'dist/mcps/enhanced-orchestrator.server.js' },
+  { name: 'enforcer', path: 'dist/mcps/enforcer-tools.server.js' },
+  { name: 'api-design', path: 'dist/mcps/knowledge-skills/api-design.server.js' },
+  { name: 'architecture-patterns', path: 'dist/mcps/knowledge-skills/architecture-patterns.server.js' },
+  { name: 'git-workflow', path: 'dist/mcps/knowledge-skills/git-workflow.server.js' },
+  { name: 'performance-optimization', path: 'dist/mcps/knowledge-skills/performance-optimization.server.js' },
+  { name: 'project-analysis', path: 'dist/mcps/knowledge-skills/project-analysis.server.js' },
+  { name: 'testing-strategy', path: 'dist/mcps/knowledge-skills/testing-strategy.server.js' },
+  { name: 'code-review', path: 'dist/mcps/knowledge-skills/code-review.server.js' },
+  { name: 'security-audit', path: 'dist/mcps/knowledge-skills/security-audit.server.js' },
+  { name: 'ui-ux-design', path: 'dist/mcps/knowledge-skills/ui-ux-design.server.js' },
+  { name: 'refactoring-strategies', path: 'dist/mcps/knowledge-skills/refactoring-strategies.server.js' },
+  { name: 'testing-best-practices', path: 'dist/mcps/knowledge-skills/testing-best-practices.server.js' }
+];
+
+class MCPServerValidator {
+  constructor() {
+    this.results = { passed: [], failed: [] };
+  }
+
+  async validateAllServers() {
+    console.log('🔍 MCP SERVER CONNECTIVITY VALIDATOR');
+    console.log('=====================================');
+    console.log(`Testing ${MCP_SERVERS.length} StringRay MCP servers...\n`);
+
+    for (const server of MCP_SERVERS) {
+      await this.validateServer(server);
+    }
+
+    this.printSummary();
+    return this.results.failed.length === 0;
+  }
+
+  async validateServer(server) {
+    const serverPath = path.join(process.cwd(), server.path);
+
+    return new Promise((resolve) => {
+      console.log(`🔧 Testing: ${server.name}`);
+
+      // Check if file exists
+      if (!fs.existsSync(serverPath)) {
+        console.log(`  ❌ File not found: ${server.path}`);
+        this.results.failed.push({ server: server.name, error: 'File not found' });
+        resolve();
+        return;
+      }
+
+      // Test server startup
+      const child = spawn('node', [serverPath], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 10000
+      });
+
+      let stdout = '';
+      let stderr = '';
+      let started = false;
+
+      child.stdout.on('data', (data) => {
+        stdout += data.toString();
+        if (stdout.includes('MCP Server') && !started) {
+          started = true;
+          console.log(`  ✅ Server started successfully`);
+        }
+      });
+
+      child.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      child.on('close', (code) => {
+        if (started && !stderr.includes('Server does not support tools')) {
+          console.log(`  ✅ Protocol compliance: OK`);
+          this.results.passed.push(server.name);
+        } else if (stderr.includes('Server does not support tools')) {
+          console.log(`  ❌ Missing tool capabilities declaration`);
+          this.results.failed.push({
+            server: server.name,
+            error: 'Missing tool capabilities'
+          });
+        } else {
+          console.log(`  ❌ Startup failed (code: ${code})`);
+          this.results.failed.push({
+            server: server.name,
+            error: `Exit code ${code}: ${stderr.slice(0, 100)}...`
+          });
+        }
+        resolve();
+      });
+
+      child.on('error', (error) => {
+        console.log(`  ❌ Process error: ${error.message}`);
+        this.results.failed.push({
+          server: server.name,
+          error: error.message
+        });
+        resolve();
+      });
+
+      // Timeout after 5 seconds - kill successfully started servers
+      setTimeout(() => {
+        if (started) {
+          child.kill();
+          console.log(`  ✅ Server running successfully (killed after 5s)`);
+          this.results.passed.push(server.name);
+        } else {
+          child.kill();
+          console.log(`  ❌ Timeout: Server failed to start within 5s`);
+          this.results.failed.push({
+            server: server.name,
+            error: 'Startup timeout'
+          });
+        }
+        resolve();
+      }, 5000);
+    });
+  }
+
+  printSummary() {
+    console.log('\n📊 MCP SERVER VALIDATION SUMMARY');
+    console.log('==================================');
+
+    console.log(`✅ Passed: ${this.results.passed.length}/${MCP_SERVERS.length}`);
+    console.log(`❌ Failed: ${this.results.failed.length}/${MCP_SERVERS.length}`);
+
+    if (this.results.failed.length > 0) {
+      console.log('\n❌ FAILED SERVERS:');
+      this.results.failed.forEach(failure => {
+        console.log(`  • ${failure.server}: ${failure.error}`);
+      });
+    }
+
+    if (this.results.passed.length > 0) {
+      console.log('\n✅ PASSED SERVERS:');
+      this.results.passed.forEach(server => {
+        console.log(`  • ${server}`);
+      });
+    }
+  }
+}
+
+// Run validation
+const validator = new MCPServerValidator();
+validator.validateAllServers().then(success => {
+  process.exit(success ? 0 : 1);
+}).catch(error => {
+  console.error('Validation failed with error:', error);
+  process.exit(1);
+});

package/scripts/validation/validate-oh-my-opencode-integration.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+
+/**
+ * oh-my-opencode Integration Validator
+ *
+ * Tests the complete integration between StringRay framework and oh-my-opencode
+ * Validates MCP server registration, plugin loading, and tool availability
+ */
+
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+class OhMyOpenCodeIntegrationValidator {
+  constructor() {
+    this.results = { passed: [], failed: [] };
+  }
+
+  async validateIntegration() {
+    console.log('🔗 OH-MY-OPENCODE INTEGRATION VALIDATOR');
+    console.log('=========================================');
+
+    const tests = [
+      this.validateMCPConfig.bind(this),
+      this.validatePluginRegistration.bind(this),
+      this.validateCodexInjection.bind(this),
+      this.validateToolAvailability.bind(this)
+    ];
+
+    for (const test of tests) {
+      await test();
+    }
+
+    this.printSummary();
+    return this.results.failed.length === 0;
+  }
+
+  async validateMCPConfig() {
+    console.log('\n🔧 Testing MCP Configuration...');
+
+    try {
+      // Check .mcp.json exists and is valid
+      const mcpConfig = JSON.parse(fs.readFileSync('.mcp.json', 'utf8'));
+      const serverCount = Object.keys(mcpConfig.mcpServers || {}).length;
+
+      if (serverCount >= 15) {
+        console.log(`  ✅ MCP config valid (${serverCount} servers configured)`);
+        this.results.passed.push('MCP Configuration');
+      } else {
+        console.log(`  ❌ Insufficient MCP servers (${serverCount} configured, need 15+)`);
+        this.results.failed.push({ test: 'MCP Configuration', error: `Only ${serverCount} servers configured` });
+      }
+    } catch (error) {
+      console.log(`  ❌ MCP config error: ${error.message}`);
+      this.results.failed.push({ test: 'MCP Configuration', error: error.message });
+    }
+  }
+
+  async validatePluginRegistration() {
+    console.log('\n🔌 Testing Plugin Registration...');
+
+    try {
+      const ohMyOpencodeConfig = JSON.parse(fs.readFileSync('.opencode/oh-my-opencode.json', 'utf8'));
+
+      if (ohMyOpencodeConfig.plugin && ohMyOpencodeConfig.plugin.some(p => p.includes('stringray-codex-injection.js'))) {
+        console.log('  ✅ StringRay plugin registered in oh-my-opencode');
+        this.results.passed.push('Plugin Registration');
+      } else {
+        console.log('  ❌ StringRay plugin not registered in oh-my-opencode');
+        this.results.failed.push({ test: 'Plugin Registration', error: 'Plugin not found in config' });
+      }
+    } catch (error) {
+      console.log(`  ❌ Plugin config error: ${error.message}`);
+      this.results.failed.push({ test: 'Plugin Registration', error: error.message });
+    }
+  }
+
+  async validateCodexInjection() {
+    console.log('\n📚 Testing Codex Injection...');
+
+    return new Promise((resolve) => {
+      const testScript = spawn('node', ['scripts/test-stringray-plugin.mjs'], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 15000
+      });
+
+      let output = '';
+      let codexFound = false;
+      let termsFound = false;
+
+      testScript.stdout.on('data', (data) => {
+        const chunk = data.toString();
+        output += chunk;
+
+        if (chunk.includes('StringRay Framework Codex v1.2.20')) {
+          codexFound = true;
+        }
+        if (chunk.includes('Progressive Prod-Ready Code')) {
+          termsFound = true;
+        }
+      });
+
+      testScript.on('close', (code) => {
+        if (code === 0 && codexFound && termsFound) {
+          console.log('  ✅ Codex injection working correctly');
+          this.results.passed.push('Codex Injection');
+        } else if (output.includes('PASSED')) {
+          console.log('  ✅ Codex injection test passed');
+          this.results.passed.push('Codex Injection');
+        } else {
+          console.log('  ❌ Codex injection failed');
+          this.results.failed.push({ test: 'Codex Injection', error: 'Codex not injected properly' });
+        }
+        resolve();
+      });
+
+      testScript.on('error', (error) => {
+        console.log(`  ❌ Codex injection test error: ${error.message}`);
+        this.results.failed.push({ test: 'Codex Injection', error: error.message });
+        resolve();
+      });
+    });
+  }
+
+  async validateToolAvailability() {
+    console.log('\n🛠️  Testing Tool Availability...');
+
+    return new Promise((resolve) => {
+      const doctor = spawn('npx', ['oh-my-opencode', 'doctor', '--verbose'], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 10000
+      });
+
+      let output = '';
+      let mcpServersFound = false;
+      let toolCount = 0;
+
+      doctor.stdout.on('data', (data) => {
+        const chunk = data.toString();
+        output += chunk;
+
+        if (chunk.includes('User MCP Configuration') && chunk.includes('server(s) configured')) {
+          mcpServersFound = true;
+          const match = chunk.match(/(\d+) user server/);
+          if (match) {
+            toolCount = parseInt(match[1]);
+          }
+        }
+      });
+
+      doctor.on('close', (code) => {
+        if (code === 0 && mcpServersFound && toolCount >= 15) {
+          console.log(`  ✅ ${toolCount} MCP tools available`);
+          this.results.passed.push('Tool Availability');
+        } else {
+          console.log(`  ❌ Insufficient tools available (${toolCount} found, need 15+)`);
+          this.results.failed.push({ test: 'Tool Availability', error: `Only ${toolCount} tools available` });
+        }
+        resolve();
+      });
+
+      doctor.on('error', (error) => {
+        console.log(`  ❌ Tool availability check error: ${error.message}`);
+        this.results.failed.push({ test: 'Tool Availability', error: error.message });
+        resolve();
+      });
+    });
+  }
+
+  printSummary() {
+    console.log('\n📊 OH-MY-OPENCODE INTEGRATION SUMMARY');
+    console.log('======================================');
+
+    console.log(`✅ Passed: ${this.results.passed.length}`);
+    console.log(`❌ Failed: ${this.results.failed.length}`);
+
+    if (this.results.failed.length > 0) {
+      console.log('\n❌ FAILED TESTS:');
+      this.results.failed.forEach(failure => {
+        console.log(`  • ${failure.test}: ${failure.error}`);
+      });
+    }
+
+    if (this.results.passed.length > 0) {
+      console.log('\n✅ PASSED TESTS:');
+      this.results.passed.forEach(test => {
+        console.log(`  • ${test}`);
+      });
+    }
+  }
+}
+
+// Run integration validation
+const validator = new OhMyOpenCodeIntegrationValidator();
+validator.validateIntegration().then(success => {
+  process.exit(success ? 0 : 1);
+}).catch(error => {
+  console.error('Integration validation failed:', error);
+  process.exit(1);
+});