strray-ai 1.0.17 → 1.0.19

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

@@ -0,0 +1,179 @@
+import { describe, it, expect } from "vitest";
+import { enforcer } from "../../agents/enforcer.js";
+import type { AgentConfig } from "../../agents/types.js";
+
+describe("Enforcer Agent Configuration", () => {
+  it("should be a valid AgentConfig object", () => {
+    // Type check - this will fail at compile time if not valid
+    const config: AgentConfig = enforcer;
+    expect(config).toBeDefined();
+  });
+
+  describe("Basic Configuration", () => {
+    it("should have correct name and model", () => {
+      expect(enforcer.name).toBe("enforcer");
+      expect(enforcer.model).toBe("opencode/grok-code");
+    });
+
+    it("should be configured as subagent mode", () => {
+      expect(enforcer.mode).toBe("subagent");
+    });
+
+    it("should have low temperature for deterministic responses", () => {
+      expect(enforcer.temperature).toBe(0.1);
+    });
+  });
+
+  describe("Description and System Prompt", () => {
+    it("should have appropriate description", () => {
+      expect(enforcer.description).toContain("StringRay Framework enforcer");
+      expect(enforcer.description).toContain("error handling");
+      expect(enforcer.description).toContain("compliance monitoring");
+    });
+
+    it("should have comprehensive system prompt", () => {
+      const system = enforcer.system;
+      expect(system).toContain("StringRay Enforcer");
+      expect(system).toContain("framework compliance");
+      expect(system).toContain("error prevention");
+      expect(system).toContain("Universal Development Codex v1.2.25");
+      expect(system).toContain("99.6% error prevention");
+      expect(system).toContain("256MB memory");
+    });
+
+    it("should define core responsibilities", () => {
+      const system = enforcer.system;
+      expect(system).toContain("Error Handling & Prevention");
+      expect(system).toContain("Performance Facilities");
+      expect(system).toContain("Compliance Monitoring");
+      expect(system).toContain("Validation & Enforcement");
+    });
+
+    it("should specify key facilities", () => {
+      const system = enforcer.system;
+      expect(system).toContain("Error boundary layers");
+      expect(system).toContain("circuit breaker patterns");
+      expect(system).toContain("Performance monitoring");
+      expect(system).toContain("256MB memory");
+      expect(system).toContain("80% CPU");
+      expect(system).toContain("45s timeout");
+      expect(system).toContain("JSON format");
+    });
+  });
+
+  describe("Tools Configuration", () => {
+    it("should have appropriate tool permissions", () => {
+      expect(enforcer.tools?.include).toContain("read");
+      expect(enforcer.tools?.include).toContain("grep");
+      expect(enforcer.tools?.include).toContain("lsp_*");
+      expect(enforcer.tools?.include).toContain("run_terminal_cmd");
+      expect(enforcer.tools?.include).toContain("lsp_diagnostics");
+      expect(enforcer.tools?.include).toContain("lsp_code_actions");
+    });
+
+    it("should not have exclude restrictions", () => {
+      expect(enforcer.tools?.exclude).toBeUndefined();
+    });
+  });
+
+  describe("Permissions Configuration", () => {
+    it("should allow edit operations", () => {
+      expect(enforcer.permission?.edit).toBe("allow");
+    });
+
+    it("should have specific bash command permissions", () => {
+      const bashPerms = enforcer.permission?.bash;
+      expect(bashPerms).toBeDefined();
+      expect(typeof bashPerms).toBe("object");
+
+      // Check individual command permissions
+      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");
+    });
+
+    it("should not have webfetch permissions defined", () => {
+      expect(enforcer.permission?.webfetch).toBeUndefined();
+    });
+  });
+
+  describe("Processor Pipeline", () => {
+    it("should define processor pipeline", () => {
+      const system = enforcer.system;
+      expect(system).toContain("Processor pipeline");
+      expect(system).toContain("codexValidation");
+      expect(system).toContain("thresholdCheck");
+      expect(system).toContain("complianceReporting");
+      expect(system).toContain("violationLogging");
+    });
+
+    it("should specify integration hooks", () => {
+      const system = enforcer.system;
+      expect(system).toContain("Integration hooks");
+      expect(system).toContain("pre/post validation");
+      expect(system).toContain("error boundary monitoring");
+      expect(system).toContain("performance tracking");
+    });
+  });
+
+  describe("Codex Compliance", () => {
+    it("should reference Universal Development Codex v1.2.25", () => {
+      const system = enforcer.system;
+      expect(system).toContain("Universal Development Codex v1.2.25");
+    });
+
+    it("should specify error prevention target", () => {
+      const system = enforcer.system;
+      expect(system).toContain("99.6% error prevention");
+    });
+
+    it("should mention zero tolerance policy", () => {
+      const system = enforcer.system;
+      expect(system).toContain("zero-tolerance");
+    });
+
+    it("should require validation against all 43 codex terms", () => {
+      const system = enforcer.system;
+      expect(system).toContain("all 43 codex terms");
+    });
+  });
+
+  describe("Performance Limits", () => {
+    it("should specify memory limit", () => {
+      const system = enforcer.system;
+      expect(system).toContain("256MB memory");
+    });
+
+    it("should specify CPU limit", () => {
+      const system = enforcer.system;
+      expect(system).toContain("80% CPU");
+    });
+
+    it("should specify timeout limit", () => {
+      const system = enforcer.system;
+      expect(system).toContain("45s timeout");
+    });
+  });
+
+  describe("Operational Guidelines", () => {
+    it("should provide actionable error message guidance", () => {
+      const system = enforcer.system;
+      expect(system).toContain("actionable error messages");
+      expect(system).toContain("context");
+    });
+
+    it("should require structured logging", () => {
+      const system = enforcer.system;
+      expect(system).toContain("structured logging");
+      expect(system).toContain("JSON format");
+    });
+
+    it("should maintain system stability goal", () => {
+      const system = enforcer.system;
+      expect(system).toContain("maintain system stability");
+      expect(system).toContain("production-ready code quality");
+    });
+  });
+});

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

@@ -0,0 +1,135 @@
+import { describe, it, expect } from "vitest";
+import {
+  builtinAgents,
+  enforcer,
+  architect,
+  orchestrator,
+  bugTriageSpecialist,
+  codeReviewer,
+  securityAuditor,
+  refactorer,
+  testArchitect,
+} from "../../agents/index.js";
+import type { AgentConfig } from "../../agents/types.js";
+
+describe("Agent Index Registry", () => {
+  describe("Builtin Agents Registry", () => {
+    it("should export a valid builtinAgents registry", () => {
+      expect(builtinAgents).toBeDefined();
+      expect(typeof builtinAgents).toBe("object");
+      expect(builtinAgents).not.toBeNull();
+    });
+
+    it("should contain expected specialized agents", () => {
+      const expectedAgents = [
+        "enforcer",
+        "architect",
+        "orchestrator",
+        "bug-triage-specialist",
+        "code-reviewer",
+        "security-auditor",
+        "refactorer",
+        "test-architect",
+      ];
+
+      expectedAgents.forEach((agentName) => {
+        expect(builtinAgents).toHaveProperty(agentName);
+      });
+
+      expect(Object.keys(builtinAgents).length).toBeGreaterThanOrEqual(8);
+    });
+
+    it("should have all agents as valid AgentConfig objects", () => {
+      Object.values(builtinAgents).forEach((agent) => {
+        expect(agent).toBeDefined();
+        expect(typeof agent).toBe("object");
+        expect(agent).toHaveProperty("name");
+        expect(agent).toHaveProperty("model");
+        expect(agent).toHaveProperty("description");
+      });
+    });
+
+    it("should have agents with correct names matching their keys", () => {
+      Object.entries(builtinAgents).forEach(([key, agent]) => {
+        expect(agent.name.toLowerCase()).toBe(key.toLowerCase());
+      });
+    });
+
+    it("should have agents configured appropriately", () => {
+      Object.values(builtinAgents).forEach((agent) => {
+        expect(["subagent", "primary"]).toContain(agent.mode);
+      });
+    });
+
+    it("should have agents with consistent model configuration", () => {
+      Object.values(builtinAgents).forEach((agent) => {
+        expect(agent.model).toBeDefined();
+        expect(typeof agent.model).toBe("string");
+      });
+    });
+
+    it("should have agents with appropriate temperature settings", () => {
+      Object.values(builtinAgents).forEach((agent) => {
+        expect(agent.temperature).toBeGreaterThanOrEqual(0.1);
+      });
+    });
+  });
+
+  describe("Individual Agent Exports", () => {
+    it("should export all individual agents", () => {
+      expect(enforcer).toBeDefined();
+      expect(architect).toBeDefined();
+      expect(orchestrator).toBeDefined();
+      expect(bugTriageSpecialist).toBeDefined();
+      expect(codeReviewer).toBeDefined();
+      expect(securityAuditor).toBeDefined();
+      expect(refactorer).toBeDefined();
+      expect(testArchitect).toBeDefined();
+    });
+
+    it("should have individual exports match registry entries", () => {
+      expect(enforcer).toBe(builtinAgents.enforcer);
+      expect(architect).toBe(builtinAgents.architect);
+      expect(orchestrator).toBe(builtinAgents.orchestrator);
+    });
+
+    it("should have all individual exports as valid AgentConfig objects", () => {
+      const agents = [
+        enforcer,
+        architect,
+        orchestrator,
+        bugTriageSpecialist,
+        codeReviewer,
+        securityAuditor,
+        refactorer,
+        testArchitect,
+      ];
+
+      agents.forEach((agent) => {
+        expect(agent).toHaveProperty("name");
+        expect(agent).toHaveProperty("model");
+        expect(agent).toHaveProperty("description");
+      });
+    });
+  });
+
+  describe("Registry Integrity", () => {
+    it("should have no duplicate agent names", () => {
+      const names = Object.values(builtinAgents).map((agent) => agent.name);
+      const uniqueNames = new Set(names);
+      expect(uniqueNames.size).toBe(names.length);
+    });
+
+    it("should have no duplicate keys", () => {
+      const keys = Object.keys(builtinAgents);
+      const uniqueKeys = new Set(keys);
+      expect(uniqueKeys.size).toBe(keys.length);
+    });
+
+    it("should have consistent naming between keys and agent names", () => {
+      Object.entries(builtinAgents).forEach(([key, agent]) => {
+        expect(agent.name.toLowerCase()).toBe(key.toLowerCase());
+      });
+    });
+  });
+});

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

@@ -0,0 +1,228 @@
+import { describe, it, expect } from "vitest";
+import { orchestrator } from "../../agents/orchestrator.js";
+import type { AgentConfig } from "../../agents/types.js";
+
+describe("Orchestrator Agent Configuration", () => {
+  it("should be a valid AgentConfig object", () => {
+    // Type check - this will fail at compile time if not valid
+    const config: AgentConfig = orchestrator;
+    expect(config).toBeDefined();
+  });
+
+  describe("Basic Configuration", () => {
+    it("should have correct name and model", () => {
+      expect(orchestrator.name).toBe("orchestrator");
+      expect(orchestrator.model).toBe("opencode/grok-code");
+    });
+
+    it("should be configured as subagent mode", () => {
+      expect(orchestrator.mode).toBe("subagent");
+    });
+
+    it("should have low temperature for consistent coordination", () => {
+      expect(orchestrator.temperature).toBe(0.1);
+    });
+  });
+
+  describe("Description and System Prompt", () => {
+    it("should have appropriate description", () => {
+      expect(orchestrator.description).toContain(
+        "StringRay Framework orchestrator",
+      );
+      expect(orchestrator.description).toContain("coordination");
+      expect(orchestrator.description).toContain("multi-agent orchestration");
+    });
+
+    it("should have comprehensive system prompt", () => {
+      const system = orchestrator.system;
+      expect(system).toContain("StringRay Orchestrator");
+      expect(system).toContain("multi-agent workflows");
+      expect(system).toContain("enterprise operations");
+    });
+
+    it("should define 8 core responsibilities", () => {
+      const system = orchestrator.system;
+      expect(system).toContain("Workflow Orchestration");
+      expect(system).toContain("Subagent Delegation");
+      expect(system).toContain("Session Management");
+      expect(system).toContain("Progress Tracking");
+      expect(system).toContain("Conflict Resolution");
+      expect(system).toContain("Completion Guarantee");
+      expect(system).toContain("Performance Optimization");
+      expect(system).toContain("Error Recovery");
+    });
+  });
+
+  describe("Key Facilities", () => {
+    it("should specify multi-agent coordination facilities", () => {
+      const system = orchestrator.system;
+      expect(system).toContain("Multi-agent coordination");
+      expect(system).toContain("async delegation");
+      expect(system).toContain("Session lifecycle management");
+      expect(system).toContain("Progress tracking");
+      expect(system).toContain("Conflict resolution");
+      expect(system).toContain("Parallel execution optimization");
+      expect(system).toContain("error recovery mechanisms");
+    });
+  });
+
+  describe("Operating Protocol", () => {
+    it("should define 6-phase operating protocol", () => {
+      const system = orchestrator.system;
+      expect(system).toContain("6-phase operating protocol");
+      expect(system).toContain("Analysis Mode");
+      expect(system).toContain("Planning Mode");
+      expect(system).toContain("Delegation Mode");
+      expect(system).toContain("Execution Mode");
+      expect(system).toContain("Resolution Mode");
+      expect(system).toContain("Completion Mode");
+    });
+
+    it("should specify protocol phases in detail", () => {
+      const system = orchestrator.system;
+      expect(system).toContain("Assess task complexity");
+      expect(system).toContain("Break complex tasks into manageable phases");
+      expect(system).toContain(
+        "Assign specialized work to appropriate subagents",
+      );
+      expect(system).toContain("Monitor parallel task execution");
+      expect(system).toContain("Handle conflicts, errors, and bottlenecks");
+      expect(system).toContain("Validate final results");
+    });
+  });
+
+  describe("Orchestration Guidelines", () => {
+    it("should specify orchestration principles", () => {
+      const system = orchestrator.system;
+      expect(system).toContain("Follow the 6-phase operating protocol");
+      expect(system).toContain("Maximize parallel execution");
+      expect(system).toContain("Maintain clear communication");
+      expect(system).toContain("Implement proper error boundaries");
+      expect(system).toContain("Ensure all tasks complete with validation");
+    });
+  });
+
+  describe("Integration Points", () => {
+    it("should define integration points", () => {
+      const system = orchestrator.system;
+      expect(system).toContain("Integration Points");
+      expect(system).toContain("Session management system");
+      expect(system).toContain("Agent delegation framework");
+      expect(system).toContain("Progress tracking and monitoring");
+      expect(system).toContain("Conflict resolution mechanisms");
+      expect(system).toContain("Performance optimization tools");
+    });
+  });
+
+  describe("Tools Configuration", () => {
+    it("should have comprehensive tool permissions for orchestration", () => {
+      expect(orchestrator.tools?.include).toContain("read");
+      expect(orchestrator.tools?.include).toContain("grep");
+      expect(orchestrator.tools?.include).toContain("lsp_*");
+      expect(orchestrator.tools?.include).toContain("run_terminal_cmd");
+      expect(orchestrator.tools?.include).toContain("background_task");
+      expect(orchestrator.tools?.include).toContain("call_omo_agent");
+      expect(orchestrator.tools?.include).toContain("session_list");
+      expect(orchestrator.tools?.include).toContain("session_read");
+      expect(orchestrator.tools?.include).toContain("session_search");
+    });
+
+    it("should have 9 orchestration-specific tools", () => {
+      expect(orchestrator.tools?.include).toHaveLength(9);
+    });
+  });
+
+  describe("Permissions Configuration", () => {
+    it("should allow edit operations", () => {
+      expect(orchestrator.permission?.edit).toBe("allow");
+    });
+
+    it("should have essential bash command permissions", () => {
+      const bashPerms = orchestrator.permission?.bash;
+      expect(bashPerms).toBeDefined();
+      expect(typeof bashPerms).toBe("object");
+
+      // Check essential commands for orchestration
+      expect((bashPerms as any)?.git).toBe("allow");
+      expect((bashPerms as any)?.npm).toBe("allow");
+      expect((bashPerms as any)?.bun).toBe("allow");
+    });
+
+    it("should not have restrictive permissions", () => {
+      expect(orchestrator.permission?.webfetch).toBeUndefined();
+    });
+  });
+
+  describe("Subagent Integration", () => {
+    it("should reference key subagents", () => {
+      const system = orchestrator.system;
+      expect(system).toContain("architect");
+      expect(system).toContain("refactorer");
+      expect(system).toContain("test-architect");
+      expect(system).toContain("enforcer");
+    });
+
+    it("should specify intelligent delegation", () => {
+      const system = orchestrator.system;
+      expect(system).toContain("Intelligently assign tasks");
+      expect(system).toContain("specialized agents");
+    });
+  });
+
+  describe("Session Management", () => {
+    it("should emphasize session lifecycle management", () => {
+      const system = orchestrator.system;
+      expect(system).toContain("Session Management");
+      expect(system).toContain("session lifecycle");
+      expect(system).toContain("state coordination");
+      expect(system).toContain("cross-session operations");
+    });
+  });
+
+  describe("Conflict Resolution", () => {
+    it("should specify conflict resolution capabilities", () => {
+      const system = orchestrator.system;
+      expect(system).toContain("Conflict Resolution");
+      expect(system).toContain("Mediate between conflicting");
+      expect(system).toContain("subagent recommendations");
+      expect(system).toContain("architectural decisions");
+    });
+  });
+
+  describe("Completion Guarantee", () => {
+    it("should ensure completion guarantee", () => {
+      const system = orchestrator.system;
+      expect(system).toContain("Completion Guarantee");
+      expect(system).toContain("complete successfully");
+      expect(system).toContain("rollback capabilities");
+    });
+  });
+
+  describe("Performance Optimization", () => {
+    it("should specify performance optimization focus", () => {
+      const system = orchestrator.system;
+      expect(system).toContain("Performance Optimization");
+      expect(system).toContain("parallel execution");
+      expect(system).toContain("maximum efficiency");
+    });
+  });
+
+  describe("Error Recovery", () => {
+    it("should implement comprehensive error handling", () => {
+      const system = orchestrator.system;
+      expect(system).toContain("Error Recovery");
+      expect(system).toContain("comprehensive error handling");
+      expect(system).toContain("recovery strategies");
+    });
+  });
+
+  describe("Orchestration Goal", () => {
+    it("should define clear orchestration goal", () => {
+      const system = orchestrator.system;
+      expect(system).toContain("flawlessly coordinate");
+      expect(system).toContain("StringRay Framework operations");
+      expect(system).toContain("intelligent orchestration");
+      expect(system).toContain("delegation");
+    });
+  });
+});