stringray-ai 1.0.15 → 1.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stringray-ai",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "description": "⚡ StringRay ⚡: Bulletproof AI orchestration with systematic error prevention. Zero dead ends. Ship clean, tested, optimized code — every time.",
   "type": "module",
   "main": "./dist/plugin/index.js",
@@ -104,7 +104,8 @@
     "dist/utils",
     "scripts",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "src"
   ],
   "exports": {
     ".": {

package/scripts/test-stringray-plugin.mjs

@@ -10,8 +10,11 @@
  * @since 2026-01-13
  */
 
+// Check for basic-only flag to prevent recursive comprehensive testing
+const isBasicOnly = process.argv.includes('--basic-only');
+
 // Path configuration for cross-environment compatibility
-// Check if we're running from a deployed environment (has stringray-ai in node_modules)
+// Check if we're running from a test environment (directory name contains 'stringray-' or 'test-')
 const cwd = process.cwd();
 const dirName = cwd.split('/').pop() || '';
 const fs = await import('fs');
@@ -21,7 +24,7 @@ const path = await import('path');
 const deployedPluginPath = path.join(cwd, 'node_modules', 'stringray-ai', 'dist', 'plugin', 'plugins');
 const isDeployedEnvironment = fs.existsSync(path.join(cwd, 'node_modules', 'stringray-ai'));
 
-// Also check directory name patterns
+// Also check directory name patterns for backward compatibility
 const isTestEnvironment = dirName.includes('stringray-') || dirName.includes('final-stringray') ||
   dirName.includes('test-') || dirName.includes('deploy-verify') || dirName.includes('final-test') ||
   dirName.includes('jelly') || isDeployedEnvironment;
@@ -62,9 +65,10 @@ console.log('=====================================\n');
          console.log('\n🎉 StringRay Framework Plugin Test: PASSED');
          console.log('✨ Framework is ready for oh-my-opencode integration');
 
-         // Run comprehensive deployment tests
-         console.log('\n🔬 Running comprehensive deployment validation...');
-         await runComprehensiveTests();
+         // Run comprehensive deployment tests unless basic-only flag is set
+         if (!isBasicOnly) {
+           await runComprehensiveTests();
+         }
        } else {
          console.log('\n❌ StringRay Framework Plugin Test: FAILED');
          process.exit(1);
@@ -78,4 +82,100 @@ console.log('=====================================\n');
     console.error('❌ Plugin loading failed:', error);
     process.exit(1);
   }
-})();
+})();
+
+// Comprehensive deployment validation function
+async function runComprehensiveTests() {
+  console.log('\n🔬 Running comprehensive deployment validation...\n');
+
+  const tests = [
+    {
+      name: 'MCP Configuration Validation',
+      command: 'node scripts/test-path-resolver.mjs',
+      description: 'Validates MCP server configuration and path resolution'
+    },
+    {
+      name: 'Plugin System Validation',
+      command: 'node scripts/test-stringray-plugin.mjs --basic-only',
+      description: 'Tests basic plugin loading without comprehensive tests'
+    },
+    {
+      name: 'Codex Integration Test',
+      command: 'node scripts/validate-codex.js',
+      description: 'Validates codex parsing and injection functionality'
+    },
+    {
+      name: 'Process Communication Test',
+      command: 'node scripts/test-comprehensive-path-resolution.mjs',
+      description: 'Tests path resolution and process communication'
+    }
+  ];
+
+  let passed = 0;
+  let failed = 0;
+
+  for (const test of tests) {
+    console.log(`🧪 Running ${test.name}...`);
+    console.log(`   ${test.description}`);
+
+    try {
+      const { spawn } = await import('child_process');
+      const [cmd, ...args] = test.command.split(' ');
+
+      await new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, {
+          stdio: ['pipe', 'pipe', 'pipe'],
+          cwd: process.cwd()
+        });
+
+        let stdout = '';
+        let stderr = '';
+
+        child.stdout.on('data', (data) => {
+          stdout += data.toString();
+        });
+
+        child.stderr.on('data', (data) => {
+          stderr += data.toString();
+        });
+
+        child.on('close', (code) => {
+          if (code === 0) {
+            console.log(`   ✅ PASSED\n`);
+            passed++;
+            resolve();
+          } else {
+            console.log(`   ❌ FAILED (exit code: ${code})`);
+            if (stderr) console.log(`   Error: ${stderr.slice(0, 200)}...`);
+            console.log('');
+            failed++;
+            resolve(); // Continue with other tests
+          }
+        });
+
+        child.on('error', (error) => {
+          console.log(`   ❌ FAILED (spawn error: ${error.message})`);
+          console.log('');
+          failed++;
+          resolve();
+        });
+      });
+    } catch (error) {
+      console.log(`   ❌ FAILED (exception: ${error.message})`);
+      console.log('');
+      failed++;
+    }
+  }
+
+  console.log('📊 Comprehensive Test Results:');
+  console.log(`   ✅ Passed: ${passed}`);
+  console.log(`   ❌ Failed: ${failed}`);
+  console.log(`   📈 Success Rate: ${Math.round((passed / (passed + failed)) * 100)}%`);
+
+  if (failed === 0) {
+    console.log('\n🎉 ALL COMPREHENSIVE TESTS PASSED!');
+    console.log('✨ StringRay Framework is fully operational and ready for production use.');
+  } else {
+    console.log(`\n⚠️  ${failed} test(s) failed. Please check the framework configuration.`);
+  }
+}

package/src/__tests__/agents/architect.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect } from "vitest";
+import { architect } from "../../agents/architect.js";
+import type { AgentConfig } from "../../agents/types.js";
+
+describe("Architect Agent Configuration", () => {
+  it("should be a valid AgentConfig object", () => {
+    const config: AgentConfig = architect;
+    expect(config).toBeDefined();
+  });
+
+  describe("Basic Configuration", () => {
+    it("should have correct name and model", () => {
+      expect(architect.name).toBe("architect");
+      expect(architect.model).toBe("opencode/grok-code");
+    });
+
+    it("should be configured as subagent mode", () => {
+      expect(architect.mode).toBe("subagent");
+    });
+
+    it("should have low temperature for consistent design decisions", () => {
+      expect(architect.temperature).toBe(0.1);
+    });
+  });
+
+  describe("Core Responsibilities", () => {
+    it("should define 4 core responsibilities", () => {
+      const system = architect.system;
+      expect(system).toContain("State Management");
+      expect(system).toContain("Delegation System");
+      expect(system).toContain("System Design");
+      expect(system).toContain("Dependency Mapping");
+    });
+
+    it("should specify state management focus", () => {
+      const system = architect.system;
+      expect(system).toContain("Maintain global state");
+      expect(system).toContain("prevent state duplication");
+    });
+
+    it("should include delegation intelligence", () => {
+      const system = architect.system;
+      expect(system).toContain("Analyze task complexity");
+      expect(system).toContain("route to appropriate specialized agents");
+    });
+  });
+
+  describe("Key Facilities", () => {
+    it("should specify architectural facilities", () => {
+      const system = architect.system;
+      expect(system).toContain("Global State Coordinator");
+      expect(system).toContain("Complexity Analysis Engine");
+      expect(system).toContain("Delegation System");
+      expect(system).toContain("state synchronization");
+    });
+
+    it("should define processor pipeline", () => {
+      const system = architect.system;
+      expect(system).toContain("Processor Pipeline");
+      expect(system).toContain("stateValidation");
+      expect(system).toContain("dependencyMapping");
+      expect(system).toContain("architectureReview");
+      expect(system).toContain("delegationOptimization");
+    });
+  });
+
+  describe("Architectural Principles", () => {
+    it("should follow shared global state principle", () => {
+      const system = architect.system;
+      expect(system).toContain("shared global state where possible");
+      expect(system).toContain("single source of truth");
+    });
+
+    it("should implement SOLID principles", () => {
+      const system = architect.system;
+      expect(system).toContain("SOLID principles");
+      expect(system).toContain("clean architecture");
+    });
+
+    it("should reference Universal Development Codex", () => {
+      const system = architect.system;
+      expect(system).toContain("Universal Development Codex v1.2.24");
+    });
+  });
+
+  describe("Tools Configuration", () => {
+    it("should have architecture-specific tools", () => {
+      expect(architect.tools?.include).toContain("read");
+      expect(architect.tools?.include).toContain("grep");
+      expect(architect.tools?.include).toContain("lsp_*");
+      expect(architect.tools?.include).toContain("run_terminal_cmd");
+      expect(architect.tools?.include).toContain("background_task");
+      expect(architect.tools?.include).toContain("lsp_goto_definition");
+      expect(architect.tools?.include).toContain("lsp_find_references");
+    });
+  });
+
+  describe("Integration Points", () => {
+    it("should define architectural integration points", () => {
+      const system = architect.system;
+      expect(system).toContain("Integration Points");
+      expect(system).toContain("State Manager");
+      expect(system).toContain("Delegation System");
+      expect(system).toContain("Boot Orchestrator");
+      expect(system).toContain("Monitoring System");
+    });
+  });
+});

package/src/__tests__/agents/bug-triage-specialist.test.ts

@@ -0,0 +1,246 @@
+import { describe, it, expect } from "vitest";
+import { bugTriageSpecialist } from "../../agents/bug-triage-specialist.js";
+import type { AgentConfig } from "../../agents/types.js";
+
+describe("Bug Triage Specialist Agent Configuration", () => {
+  it("should be a valid AgentConfig object", () => {
+    const config: AgentConfig = bugTriageSpecialist;
+    expect(config).toBeDefined();
+  });
+
+  describe("Basic Configuration", () => {
+    it("should have correct name and model", () => {
+      expect(bugTriageSpecialist.name).toBe("bug-triage-specialist");
+      expect(bugTriageSpecialist.model).toBe("opencode/grok-code");
+    });
+
+    it("should be configured as subagent mode", () => {
+      expect(bugTriageSpecialist.mode).toBe("subagent");
+    });
+
+    it("should have low temperature for consistent triage decisions", () => {
+      expect(bugTriageSpecialist.temperature).toBe(0.1);
+    });
+  });
+
+  describe("Description and System Prompt", () => {
+    it("should have appropriate bug triage description", () => {
+      expect(bugTriageSpecialist.description).toContain(
+        "StringRay Framework bug triage specialist",
+      );
+      expect(bugTriageSpecialist.description).toContain(
+        "systematic error investigation",
+      );
+      expect(bugTriageSpecialist.description).toContain("surgical fixes");
+    });
+
+    it("should have comprehensive bug triage specialist system prompt", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("StringRay Bug Triage Specialist");
+      expect(system).toContain("systematic error investigation");
+      expect(system).toContain("surgical code fixes");
+    });
+  });
+
+  describe("Core Responsibilities", () => {
+    it("should define 5 core bug triage responsibilities", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("Error Investigation");
+      expect(system).toContain("Surgical Fixes");
+      expect(system).toContain("Impact Assessment");
+      expect(system).toContain("Recovery Strategy");
+      expect(system).toContain("Performance Optimization");
+    });
+
+    it("should specify systematic error investigation", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("systematic root cause analysis");
+      expect(system).toContain("comprehensive investigation depth");
+    });
+
+    it("should specify surgical fixes approach", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("precise, targeted fixes");
+      expect(system).toContain("root causes");
+      expect(system).toContain("without side effects");
+    });
+
+    it("should include impact assessment", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("error severity");
+      expect(system).toContain("system-wide impact");
+    });
+
+    it("should specify recovery strategy development", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("graceful error recovery mechanisms");
+    });
+
+    it("should include performance optimization", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("performance bottlenecks");
+    });
+  });
+
+  describe("Key Facilities", () => {
+    it("should specify systematic investigation facilities", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("Systematic investigation");
+      expect(system).toContain("30-second root cause timeout");
+    });
+
+    it("should include error boundary layers", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("Error boundary layers");
+      expect(system).toContain("3 levels");
+      expect(system).toContain("circuit breaker patterns");
+    });
+
+    it("should specify performance profiling", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("Performance profiling");
+      expect(system).toContain("triage efficiency tracking");
+    });
+
+    it("should include bottleneck detection", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("Bottleneck detection");
+      expect(system).toContain("resource usage monitoring");
+    });
+
+    it("should define bug triage processor pipeline", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("Processor pipeline");
+      expect(system).toContain("error-analysis");
+      expect(system).toContain("root-cause-investigation");
+      expect(system).toContain("fix-validation");
+      expect(system).toContain("impact-assessment");
+    });
+  });
+
+  describe("Investigation Process", () => {
+    it("should define 5-phase investigation process", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("Investigation Process");
+      expect(system).toContain("Error Classification");
+      expect(system).toContain("Root Cause Analysis");
+      expect(system).toContain("Impact Assessment");
+      expect(system).toContain("Surgical Fix Development");
+      expect(system).toContain("Validation & Testing");
+    });
+
+    it("should specify error classification", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("severity");
+      expect(system).toContain("critical, high, medium, low");
+    });
+
+    it("should include root cause analysis", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("underlying causes");
+      expect(system).toContain("symptoms");
+    });
+
+    it("should specify impact assessment", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("system-wide effects");
+      expect(system).toContain("dependencies");
+    });
+
+    it("should specify surgical fix development", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("targeted fixes");
+      expect(system).toContain("minimal changes");
+    });
+
+    it("should include validation and testing", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("resolve issues");
+      expect(system).toContain("introducing new problems");
+    });
+  });
+
+  describe("Bug Triage Guidelines", () => {
+    it("should emphasize systematic investigation", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("systematic investigation");
+      expect(system).toContain("never guess");
+    });
+
+    it("should specify surgical fixes", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("surgical fixes");
+      expect(system).toContain("change only what's necessary");
+    });
+
+    it("should require thorough validation", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("Validate fixes thoroughly");
+      expect(system).toContain("deployment");
+    });
+
+    it("should maintain error boundary integrity", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("error boundary integrity");
+    });
+
+    it("should specify documentation requirements", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("detailed fix documentation");
+    });
+  });
+
+  describe("Integration Points", () => {
+    it("should define comprehensive bug triage integration points", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("Integration Points");
+      expect(system).toContain("Error monitoring");
+      expect(system).toContain("Performance tracking");
+      expect(system).toContain("Code analysis");
+      expect(system).toContain("Automated testing");
+    });
+  });
+
+  describe("Tools Configuration", () => {
+    it("should have comprehensive bug triage tools", () => {
+      expect(bugTriageSpecialist.tools?.include).toContain("read");
+      expect(bugTriageSpecialist.tools?.include).toContain("grep");
+      expect(bugTriageSpecialist.tools?.include).toContain("lsp_*");
+      expect(bugTriageSpecialist.tools?.include).toContain("run_terminal_cmd");
+      expect(bugTriageSpecialist.tools?.include).toContain("ast_grep_search");
+      expect(bugTriageSpecialist.tools?.include).toContain("ast_grep_replace");
+      expect(bugTriageSpecialist.tools?.include).toContain("lsp_diagnostics");
+      expect(bugTriageSpecialist.tools?.include).toContain("lsp_code_actions");
+    });
+
+    it("should have 8 bug triage-specific tools", () => {
+      expect(bugTriageSpecialist.tools?.include).toHaveLength(8);
+    });
+  });
+
+  describe("Permissions Configuration", () => {
+    it("should allow edit operations", () => {
+      expect(bugTriageSpecialist.permission?.edit).toBe("allow");
+    });
+
+    it("should have bug triage tool permissions", () => {
+      const bashPerms = bugTriageSpecialist.permission?.bash;
+      expect(bashPerms).toBeDefined();
+      expect(typeof bashPerms).toBe("object");
+
+      expect((bashPerms as any)?.git).toBe("allow");
+      expect((bashPerms as any)?.npm).toBe("allow");
+      expect((bashPerms as any)?.bun).toBe("allow");
+      expect((bashPerms as any)?.test).toBe("allow");
+    });
+  });
+
+  describe("Bug Triage Goal", () => {
+    it("should define clear bug elimination goal", () => {
+      const system = bugTriageSpecialist.system;
+      expect(system).toContain("eliminate bugs");
+      expect(system).toContain("systematic investigation");
+      expect(system).toContain("strengthen system reliability");
+    });
+  });
+});