strray-ai 1.0.17 → 1.0.19

package/opencode.json

@@ -1,14 +1,12 @@
 {
   "$schema": "https://opencode.ai/config.json",
   "mcp": {
-    // Disable problematic default MCP servers
     "context7": { "enabled": false },
     "global-everything": { "enabled": false },
     "global-filesystem": { "enabled": false },
     "global-git": { "enabled": false },
     "global-sqlite": { "enabled": false },
     "grep_app": { "enabled": false },
-    // Enable our custom StrRay MCP servers
     "orchestrator": {
       "type": "local",
       "command": ["node", "dist/plugin/mcps/orchestrator.server.js"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strray-ai",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "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",
@@ -123,6 +123,7 @@
     "dist/processors",
     "dist/state",
     "dist/utils",
+    "src/__tests__",
     "README.md",
     "LICENSE"
   ],

package/scripts/postinstall.cjs

@@ -428,6 +428,59 @@ function configureStrRayPlugin() {
     }
   }
 
+  // Update paths in test files
+  console.log("Checking test files for path updates...");
+  const testDir = path.join(process.cwd(), "node_modules", "strray-ai", "src", "__tests__");
+  if (fs.existsSync(testDir)) {
+    console.log("Test files found, updating paths...");
+    let testFilesUpdated = 0;
+
+    function processTestFile(filePath) {
+      try {
+        let content = fs.readFileSync(filePath, "utf-8");
+        let updated = false;
+
+        // Convert dist/plugin paths to node_modules/strray-ai/dist/plugin paths
+        if (content.includes('./dist/plugin/')) {
+          content = content.replace(/'\.\/dist\/plugin\//g, "'./node_modules/strray-ai/dist/plugin/");
+          content = content.replace(/"\.\/dist\/plugin\//g, '"./node_modules/strray-ai/dist/plugin/');
+          updated = true;
+        }
+
+        if (updated) {
+          fs.writeFileSync(filePath, content);
+          testFilesUpdated++;
+          console.log(`✅ Updated test file: ${path.relative(process.cwd(), filePath)}`);
+        }
+      } catch (error) {
+        console.warn(`Warning: Could not update test file ${filePath}:`, error.message);
+      }
+    }
+
+    function processDirectory(dirPath) {
+      const items = fs.readdirSync(dirPath);
+      for (const item of items) {
+        const fullPath = path.join(dirPath, item);
+        const stat = fs.statSync(fullPath);
+        if (stat.isDirectory()) {
+          processDirectory(fullPath);
+        } else if (item.endsWith('.ts') || item.endsWith('.js')) {
+          processTestFile(fullPath);
+        }
+      }
+    }
+
+    processDirectory(testDir);
+
+    if (testFilesUpdated > 0) {
+      console.log(`✅ Updated ${testFilesUpdated} test files with consumer paths`);
+    } else {
+      console.log("ℹ️ No test file path updates needed");
+    }
+  } else {
+    console.log("ℹ️ Test files not found (this is normal for some installations)");
+  }
+
   // All configuration paths are now updated for consumer usage
 
   console.log('🎉 StrRay plugin installation complete!');

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.25");
+    });
+  });
+
+  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");
+    });
+  });
+});

package/src/__tests__/agents/code-reviewer.test.ts

@@ -0,0 +1,242 @@
+import { describe, it, expect } from "vitest";
+import { codeReviewer } from "../../agents/code-reviewer.js";
+import type { AgentConfig } from "../../agents/types.js";
+
+describe("Code Reviewer Agent Configuration", () => {
+  it("should be a valid AgentConfig object", () => {
+    const config: AgentConfig = codeReviewer;
+    expect(config).toBeDefined();
+  });
+
+  describe("Basic Configuration", () => {
+    it("should have correct name and model", () => {
+      expect(codeReviewer.name).toBe("code-reviewer");
+      expect(codeReviewer.model).toBe("opencode/grok-code");
+    });
+
+    it("should be configured as subagent mode", () => {
+      expect(codeReviewer.mode).toBe("subagent");
+    });
+
+    it("should have low temperature for consistent review standards", () => {
+      expect(codeReviewer.temperature).toBe(0.1);
+    });
+  });
+
+  describe("Description and System Prompt", () => {
+    it("should have appropriate code review description", () => {
+      expect(codeReviewer.description).toContain(
+        "StringRay Framework code reviewer",
+      );
+      expect(codeReviewer.description).toContain("monitoring");
+      expect(codeReviewer.description).toContain("analytics");
+      expect(codeReviewer.description).toContain("quality assurance");
+    });
+
+    it("should have comprehensive code reviewer system prompt", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("StringRay Code Reviewer");
+      expect(system).toContain("code quality assurance");
+      expect(system).toContain("monitoring");
+      expect(system).toContain("comprehensive analysis");
+    });
+  });
+
+  describe("Core Responsibilities", () => {
+    it("should define 5 core code review responsibilities", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("Code Quality Assessment");
+      expect(system).toContain("Monitoring & Analytics");
+      expect(system).toContain("Best Practice Validation");
+      expect(system).toContain("Security Review");
+      expect(system).toContain("Performance Impact Analysis");
+    });
+
+    it("should reference Universal Development Codex", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("Universal Development Codex v1.2.25");
+    });
+
+    it("should specify monitoring and analytics capabilities", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("review throughput");
+      expect(system).toContain("quality scores");
+      expect(system).toContain("performance patterns");
+    });
+
+    it("should include security review responsibilities", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("security vulnerabilities");
+      expect(system).toContain("compliance issues");
+    });
+
+    it("should specify performance impact analysis", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("performance implications");
+    });
+  });
+
+  describe("Key Facilities", () => {
+    it("should specify monitoring facilities", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("Real-time monitoring");
+      expect(system).toContain("review_throughput");
+      expect(system).toContain("quality_score_trends");
+      expect(system).toContain("false_positive_rate");
+    });
+
+    it("should include analytics engine capabilities", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("Analytics engine");
+      expect(system).toContain("performance patterns");
+      expect(system).toContain("predictive models");
+      expect(system).toContain("defect detection");
+    });
+
+    it("should define review processor pipeline", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("Processor pipeline");
+      expect(system).toContain("quality-assessment");
+      expect(system).toContain("compliance-validation");
+      expect(system).toContain("security-review");
+      expect(system).toContain("performance-impact");
+    });
+
+    it("should specify alert thresholds", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("Alert thresholds");
+      expect(system).toContain("20s response time");
+      expect(system).toContain("2% error rate");
+      expect(system).toContain("200MB memory usage");
+    });
+  });
+
+  describe("Review Process", () => {
+    it("should define 5-phase review process", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("Review Process");
+      expect(system).toContain("Static Analysis");
+      expect(system).toContain("Security Scanning");
+      expect(system).toContain("Performance Review");
+      expect(system).toContain("Architecture Validation");
+      expect(system).toContain("Documentation Review");
+    });
+
+    it("should specify static analysis phase", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("Automated code quality checks");
+      expect(system).toContain("linting");
+    });
+
+    it("should include security scanning", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("Vulnerability detection");
+      expect(system).toContain("security best practice validation");
+    });
+
+    it("should specify performance review", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("Impact assessment");
+      expect(system).toContain("system performance");
+      expect(system).toContain("scalability");
+    });
+
+    it("should include architecture validation", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("design principles");
+      expect(system).toContain("patterns");
+    });
+
+    it("should specify documentation review", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("code documentation");
+      expect(system).toContain("maintainability");
+    });
+  });
+
+  describe("Review Guidelines", () => {
+    it("should reference all 43 codex terms validation", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("all 43 codex terms");
+    });
+
+    it("should prioritize correctness over style", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("correctness over style");
+    });
+
+    it("should provide actionable feedback", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("actionable feedback");
+      expect(system).toContain("specific recommendations");
+    });
+
+    it("should consider multiple quality dimensions", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("performance");
+      expect(system).toContain("security");
+      expect(system).toContain("maintainability");
+    });
+
+    it("should use data-driven insights", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("data-driven insights");
+      expect(system).toContain("monitoring and analytics");
+    });
+  });
+
+  describe("Integration Points", () => {
+    it("should define comprehensive code review integration points", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("Integration Points");
+      expect(system).toContain("Code analysis and LSP integration");
+      expect(system).toContain("Security scanning");
+      expect(system).toContain("Performance monitoring");
+      expect(system).toContain("Automated testing");
+      expect(system).toContain("Documentation generation");
+    });
+  });
+
+  describe("Tools Configuration", () => {
+    it("should have comprehensive code analysis tools", () => {
+      expect(codeReviewer.tools?.include).toContain("read");
+      expect(codeReviewer.tools?.include).toContain("grep");
+      expect(codeReviewer.tools?.include).toContain("lsp_*");
+      expect(codeReviewer.tools?.include).toContain("run_terminal_cmd");
+      expect(codeReviewer.tools?.include).toContain("lsp_diagnostics");
+      expect(codeReviewer.tools?.include).toContain("lsp_code_actions");
+      expect(codeReviewer.tools?.include).toContain("lsp_code_action_resolve");
+    });
+
+    it("should have 7 code review-specific tools", () => {
+      expect(codeReviewer.tools?.include).toHaveLength(7);
+    });
+  });
+
+  describe("Permissions Configuration", () => {
+    it("should allow edit operations", () => {
+      expect(codeReviewer.permission?.edit).toBe("allow");
+    });
+
+    it("should have code quality tool permissions", () => {
+      const bashPerms = codeReviewer.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)?.eslint).toBe("allow");
+      expect((bashPerms as any)?.prettier).toBe("allow");
+    });
+  });
+
+  describe("Code Quality Goal", () => {
+    it("should define clear code quality maintenance goal", () => {
+      const system = codeReviewer.system;
+      expect(system).toContain("highest standards of code quality");
+      expect(system).toContain("actionable insights");
+      expect(system).toContain("continuous improvement");
+    });
+  });
+});