strray-ai 1.0.17 → 1.0.18

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

@@ -0,0 +1,256 @@
+import { describe, it, expect } from "vitest";
+import { testArchitect } from "../../agents/test-architect.js";
+import type { AgentConfig } from "../../agents/types.js";
+
+describe("Test Architect Agent Configuration", () => {
+  it("should be a valid AgentConfig object", () => {
+    const config: AgentConfig = testArchitect;
+    expect(config).toBeDefined();
+  });
+
+  describe("Basic Configuration", () => {
+    it("should have correct name and model", () => {
+      expect(testArchitect.name).toBe("test-architect");
+      expect(testArchitect.model).toBe("opencode/grok-code");
+    });
+
+    it("should be configured as subagent mode", () => {
+      expect(testArchitect.mode).toBe("subagent");
+    });
+
+    it("should have low temperature for consistent testing decisions", () => {
+      expect(testArchitect.temperature).toBe(0.1);
+    });
+  });
+
+  describe("Description and System Prompt", () => {
+    it("should have appropriate test architect description", () => {
+      expect(testArchitect.description).toContain(
+        "StringRay Framework test architect",
+      );
+      expect(testArchitect.description).toContain("automatic test generation");
+      expect(testArchitect.description).toContain("coverage optimization");
+      expect(testArchitect.description).toContain("behavioral testing");
+    });
+
+    it("should have comprehensive test architect system prompt", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("StringRay Test Architect");
+      expect(system).toContain("comprehensive testing strategy");
+      expect(system).toContain("quality assurance");
+    });
+  });
+
+  describe("Core Responsibilities", () => {
+    it("should define 6 core testing responsibilities", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("Test Auto-Creation");
+      expect(system).toContain("Test Strategy Design");
+      expect(system).toContain("Coverage Optimization");
+      expect(system).toContain("Behavioral Testing");
+      expect(system).toContain("Performance Validation");
+      expect(system).toContain("Quality Assurance");
+    });
+
+    it("should specify test strategy design capabilities", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("comprehensive testing plans");
+      expect(system).toContain("unit, integration, and E2E scenarios");
+    });
+
+    it("should include coverage optimization focus", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("Maximize test coverage");
+      expect(system).toContain("minimizing redundancy");
+      expect(system).toContain("maintenance overhead");
+    });
+
+    it("should specify behavioral testing approach", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("behavior validation");
+      expect(system).toContain("implementation details");
+    });
+
+    it("should include performance validation", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("performance requirements");
+      expect(system).toContain("scalability");
+    });
+
+    it("should specify quality assurance goals", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("85%+ test coverage");
+      expect(system).toContain("reliable, maintainable test suites");
+    });
+  });
+
+  describe("Key Facilities", () => {
+    it("should specify test coverage tracking", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("Test coverage tracking");
+      expect(system).toContain("coverage_trends");
+      expect(system).toContain("test_execution_time");
+      expect(system).toContain("flaky_test_rate");
+    });
+
+    it("should include performance analytics", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("Performance analytics");
+      expect(system).toContain("execution timing patterns");
+      expect(system).toContain("failure prediction models");
+    });
+
+    it("should define testing processor pipeline", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("Processor pipeline");
+      expect(system).toContain("test-validation");
+      expect(system).toContain("coverage-analysis");
+      expect(system).toContain("performance-testing");
+      expect(system).toContain("integration-testing");
+    });
+
+    it("should specify alert thresholds", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("Alert thresholds");
+      expect(system).toContain("40s response time");
+      expect(system).toContain("2% error rate");
+      expect(system).toContain("400MB memory usage");
+    });
+
+    it("should specify parallel execution capabilities", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("Parallel test execution");
+      expect(system).toContain("4+ worker threads");
+    });
+  });
+
+  describe("Testing Strategy", () => {
+    it("should define 5-level testing strategy", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("Testing Strategy");
+      expect(system).toContain("Unit Testing");
+      expect(system).toContain("Integration Testing");
+      expect(system).toContain("End-to-End Testing");
+      expect(system).toContain("Performance Testing");
+      expect(system).toContain("Security Testing");
+    });
+
+    it("should specify unit testing focus", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("Pure functions");
+      expect(system).toContain("component isolation");
+      expect(system).toContain("edge case coverage");
+    });
+
+    it("should include integration testing", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("Component interaction");
+      expect(system).toContain("API validation");
+      expect(system).toContain("data flow testing");
+    });
+
+    it("should specify end-to-end testing", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("Complete user workflows");
+      expect(system).toContain("critical path validation");
+    });
+
+    it("should include performance testing", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("Load testing");
+      expect(system).toContain("scalability validation");
+      expect(system).toContain("bottleneck identification");
+    });
+
+    it("should specify security testing", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("Input validation");
+      expect(system).toContain("authentication");
+      expect(system).toContain("authorization testing");
+    });
+  });
+
+  describe("Testing Guidelines", () => {
+    it("should prioritize behavior over implementation", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("behavior over implementation details");
+    });
+
+    it("should specify coverage requirements", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("85%+ coverage");
+      expect(system).toContain("all test types");
+    });
+
+    it("should emphasize parallel execution", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("parallel execution");
+      expect(system).toContain("efficiency");
+    });
+
+    it("should include predictive models", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("predictive models");
+      expect(system).toContain("failure prevention");
+    });
+
+    it("should validate both positive and negative scenarios", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("positive and negative test scenarios");
+    });
+  });
+
+  describe("Integration Points", () => {
+    it("should define comprehensive testing integration points", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("Integration Points");
+      expect(system).toContain("Automated testing frameworks");
+      expect(system).toContain("Coverage analysis");
+      expect(system).toContain("Performance monitoring");
+      expect(system).toContain("CI/CD pipeline integration");
+      expect(system).toContain("Test result analysis");
+    });
+  });
+
+  describe("Tools Configuration", () => {
+    it("should have essential testing tools", () => {
+      expect(testArchitect.tools?.include).toContain("read");
+      expect(testArchitect.tools?.include).toContain("grep");
+      expect(testArchitect.tools?.include).toContain("lsp_*");
+      expect(testArchitect.tools?.include).toContain("run_terminal_cmd");
+      expect(testArchitect.tools?.include).toContain("write");
+    });
+
+    it("should have 6 testing-specific tools", () => {
+      expect(testArchitect.tools?.include).toHaveLength(6);
+    });
+  });
+
+  describe("Permissions Configuration", () => {
+    it("should allow edit operations", () => {
+      expect(testArchitect.permission?.edit).toBe("allow");
+    });
+
+    it("should have comprehensive testing permissions", () => {
+      const bashPerms = testArchitect.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");
+      expect((bashPerms as any)?.coverage).toBe("allow");
+    });
+  });
+
+  describe("Testing Goal", () => {
+    it("should define clear testing assurance goal", () => {
+      const system = testArchitect.system;
+      expect(system).toContain("comprehensive test coverage");
+      expect(system).toContain("reliable validation");
+      expect(system).toContain("system behavior");
+      expect(system).toContain("performance");
+    });
+  });
+});

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

@@ -0,0 +1,210 @@
+import { describe, it, expect } from "vitest";
+import type {
+  ToolConfig,
+  PermissionConfig,
+  AgentConfig,
+} from "../../agents/types.js";
+
+describe("Agent Types", () => {
+  describe("ToolConfig", () => {
+    it("should allow basic include/exclude configuration", () => {
+      const config: ToolConfig = {
+        include: ["*.ts", "*.tsx"],
+        exclude: ["*.test.ts", "*.spec.ts"],
+      };
+
+      expect(config.include).toEqual(["*.ts", "*.tsx"]);
+      expect(config.exclude).toEqual(["*.test.ts", "*.spec.ts"]);
+    });
+
+    it("should allow additional properties via index signature", () => {
+      const config: ToolConfig = {
+        include: ["*.js"],
+        customProperty: "value",
+        anotherProp: 42,
+      };
+
+      expect(config.customProperty).toBe("value");
+      expect(config.anotherProp).toBe(42);
+    });
+
+    it("should allow empty configuration", () => {
+      const config: ToolConfig = {};
+
+      expect(config).toEqual({});
+    });
+  });
+
+  describe("PermissionConfig", () => {
+    it("should support simple permission values", () => {
+      const config: PermissionConfig = {
+        edit: "allow",
+        bash: "deny",
+        webfetch: "ask",
+      };
+
+      expect(config.edit).toBe("allow");
+      expect(config.bash).toBe("deny");
+      expect(config.webfetch).toBe("ask");
+    });
+
+    it("should support detailed bash command permissions", () => {
+      const config: PermissionConfig = {
+        bash: {
+          git: "allow",
+          "npm install": "ask",
+          "rm -rf": "deny",
+        },
+      };
+
+      expect(config.bash).toEqual({
+        git: "allow",
+        "npm install": "ask",
+        "rm -rf": "deny",
+      });
+    });
+
+    it("should allow additional permission properties", () => {
+      const config: PermissionConfig = {
+        edit: "allow",
+        customPermission: "value",
+      };
+
+      expect(config.customPermission).toBe("value");
+    });
+  });
+
+  describe("AgentConfig", () => {
+    const validConfig: AgentConfig = {
+      name: "test-agent",
+      model: "gpt-4",
+      description: "A test agent",
+      mode: "primary",
+      system: "You are a helpful assistant",
+    };
+
+    it("should accept minimal required configuration", () => {
+      expect(validConfig.name).toBe("test-agent");
+      expect(validConfig.model).toBe("gpt-4");
+      expect(validConfig.description).toBe("A test agent");
+      expect(validConfig.mode).toBe("primary");
+      expect(validConfig.system).toBe("You are a helpful assistant");
+    });
+
+    it("should support all optional fields", () => {
+      const fullConfig: AgentConfig = {
+        name: "full-agent",
+        model: "claude-3",
+        description: "Full featured agent",
+        mode: "subagent",
+        system: "System prompt",
+        temperature: 0.7,
+        top_p: 0.9,
+        tools: {
+          include: ["read", "write"],
+          exclude: ["dangerous"],
+        },
+        permission: {
+          edit: "allow",
+          bash: "ask",
+        },
+        prompt: "Custom prompt",
+        prompt_append: "Additional instructions",
+        disable: false,
+        color: "#ff0000",
+      };
+
+      expect(fullConfig.temperature).toBe(0.7);
+      expect(fullConfig.top_p).toBe(0.9);
+      expect(fullConfig.tools?.include).toEqual(["read", "write"]);
+      expect(fullConfig.permission?.edit).toBe("allow");
+      expect(fullConfig.prompt).toBe("Custom prompt");
+      expect(fullConfig.prompt_append).toBe("Additional instructions");
+      expect(fullConfig.disable).toBe(false);
+      expect(fullConfig.color).toBe("#ff0000");
+    });
+
+    it("should support all mode values", () => {
+      const primaryConfig: AgentConfig = { ...validConfig, mode: "primary" };
+      const subagentConfig: AgentConfig = { ...validConfig, mode: "subagent" };
+      const allConfig: AgentConfig = { ...validConfig, mode: "all" };
+
+      expect(primaryConfig.mode).toBe("primary");
+      expect(subagentConfig.mode).toBe("subagent");
+      expect(allConfig.mode).toBe("all");
+    });
+
+    it("should handle disable flag", () => {
+      const enabledConfig: AgentConfig = { ...validConfig, disable: false };
+      const disabledConfig: AgentConfig = { ...validConfig, disable: true };
+
+      expect(enabledConfig.disable).toBe(false);
+      expect(disabledConfig.disable).toBe(true);
+    });
+  });
+
+  describe("Type Safety and Serialization", () => {
+    it("should serialize and deserialize AgentConfig correctly", () => {
+      const config: AgentConfig = {
+        name: "serialization-test",
+        model: "test-model",
+        description: "Testing serialization",
+        mode: "primary",
+        system: "Test system",
+        temperature: 0.5,
+        tools: { include: ["test"] },
+        permission: { edit: "allow" },
+      };
+
+      const serialized = JSON.stringify(config);
+      const deserialized = JSON.parse(serialized) as AgentConfig;
+
+      expect(deserialized.name).toBe(config.name);
+      expect(deserialized.model).toBe(config.model);
+      expect(deserialized.temperature).toBe(config.temperature);
+      expect(deserialized.tools?.include).toEqual(config.tools?.include);
+      expect(deserialized.permission?.edit).toBe(config.permission?.edit);
+    });
+
+    it("should maintain type safety with complex nested structures", () => {
+      const config: AgentConfig = {
+        name: "complex-agent",
+        model: "advanced-model",
+        description: "Complex configuration test",
+        mode: "all",
+        system: "Complex system",
+        temperature: 0.8,
+        tools: {
+          include: ["read", "write", "execute"],
+          exclude: ["delete", "dangerous"],
+          customTool: "enabled",
+          timeout: 5000,
+        },
+        permission: {
+          edit: "allow",
+          bash: {
+            "git status": "allow",
+            "npm test": "allow",
+            sudo: "deny",
+          },
+          webfetch: "ask",
+          customPerm: "value",
+        },
+        prompt: "Main prompt",
+        prompt_append: "Additional context",
+        disable: false,
+        color: "#00ff00",
+      };
+
+      // TypeScript should enforce all these types at compile time
+      expect(typeof config.name).toBe("string");
+      expect(typeof config.model).toBe("string");
+      expect(typeof config.description).toBe("string");
+      expect(["primary", "subagent", "all"]).toContain(config.mode);
+      expect(typeof config.system).toBe("string");
+      expect(typeof config.temperature).toBe("number"); // This field is set in the config
+      expect(Array.isArray(config.tools?.include)).toBe(true);
+      expect(["ask", "allow", "deny"]).toContain(config.permission?.edit);
+    });
+  });
+});