strray-ai 1.0.17 → 1.0.18

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

@@ -0,0 +1,248 @@
+import { describe, it, expect } from "vitest";
+import { refactorer } from "../../agents/refactorer.js";
+import type { AgentConfig } from "../../agents/types.js";
+
+describe("Refactorer Agent Configuration", () => {
+  it("should be a valid AgentConfig object", () => {
+    const config: AgentConfig = refactorer;
+    expect(config).toBeDefined();
+  });
+
+  describe("Basic Configuration", () => {
+    it("should have correct name and model", () => {
+      expect(refactorer.name).toBe("refactorer");
+      expect(refactorer.model).toBe("opencode/grok-code");
+    });
+
+    it("should be configured as subagent mode", () => {
+      expect(refactorer.mode).toBe("subagent");
+    });
+
+    it("should have low temperature for consistent refactoring decisions", () => {
+      expect(refactorer.temperature).toBe(0.1);
+    });
+  });
+
+  describe("Description and System Prompt", () => {
+    it("should have appropriate refactoring description", () => {
+      expect(refactorer.description).toContain("StringRay Framework refactorer");
+      expect(refactorer.description).toContain("technical debt elimination");
+      expect(refactorer.description).toContain("code consolidation");
+    });
+
+    it("should have comprehensive refactorer system prompt", () => {
+      const system = refactorer.system;
+      expect(system).toContain("StringRay Refactorer");
+      expect(system).toContain("technical debt elimination");
+      expect(system).toContain("surgical code improvements");
+    });
+  });
+
+  describe("Core Responsibilities", () => {
+    it("should define 5 core refactoring responsibilities", () => {
+      const system = refactorer.system;
+      expect(system).toContain("Technical Debt Elimination");
+      expect(system).toContain("Code Consolidation");
+      expect(system).toContain("Surgical Refactoring");
+      expect(system).toContain("Performance Optimization");
+      expect(system).toContain("Maintainability Enhancement");
+    });
+
+    it("should specify technical debt elimination focus", () => {
+      const system = refactorer.system;
+      expect(system).toContain("reduce code complexity");
+      expect(system).toContain("maintainability issues");
+    });
+
+    it("should include code consolidation capabilities", () => {
+      const system = refactorer.system;
+      expect(system).toContain("Merge duplicate code");
+      expect(system).toContain("eliminate redundancy");
+      expect(system).toContain("preserving functionality");
+    });
+
+    it("should specify surgical refactoring approach", () => {
+      const system = refactorer.system;
+      expect(system).toContain("precise code improvements");
+      expect(system).toContain("without introducing regressions");
+    });
+
+    it("should include performance optimization", () => {
+      const system = refactorer.system;
+      expect(system).toContain("code efficiency");
+      expect(system).toContain("resource utilization");
+    });
+
+    it("should specify maintainability enhancement", () => {
+      const system = refactorer.system;
+      expect(system).toContain("readability");
+      expect(system).toContain("testability");
+      expect(system).toContain("long-term maintainability");
+    });
+  });
+
+  describe("Key Facilities", () => {
+    it("should specify code analysis facilities", () => {
+      const system = refactorer.system;
+      expect(system).toContain("Code analysis");
+      expect(system).toContain("technical debt assessment");
+      expect(system).toContain("30-second timeout");
+    });
+
+    it("should include refactoring validation capabilities", () => {
+      const system = refactorer.system;
+      expect(system).toContain("Refactoring validation");
+      expect(system).toContain("impact analysis");
+      expect(system).toContain("10-second timeout");
+    });
+
+    it("should specify consolidation metrics", () => {
+      const system = refactorer.system;
+      expect(system).toContain("Consolidation metrics");
+      expect(system).toContain("efficiency tracking");
+    });
+
+    it("should define refactoring processor pipeline", () => {
+      const system = refactorer.system;
+      expect(system).toContain("Processor pipeline");
+      expect(system).toContain("code-analysis");
+      expect(system).toContain("technical-debt-assessment");
+      expect(system).toContain("refactoring-validation");
+      expect(system).toContain("consolidation-impact");
+    });
+
+    it("should specify AST manipulation tools", () => {
+      const system = refactorer.system;
+      expect(system).toContain("AST manipulation tools");
+      expect(system).toContain("surgical code transformations");
+    });
+  });
+
+  describe("Refactoring Process", () => {
+    it("should define 5-phase refactoring process", () => {
+      const system = refactorer.system;
+      expect(system).toContain("Refactoring Process");
+      expect(system).toContain("Debt Assessment");
+      expect(system).toContain("Impact Analysis");
+      expect(system).toContain("Surgical Implementation");
+      expect(system).toContain("Validation & Testing");
+      expect(system).toContain("Consolidation");
+    });
+
+    it("should specify debt assessment phase", () => {
+      const system = refactorer.system;
+      expect(system).toContain("technical debt indicators");
+      expect(system).toContain("complexity metrics");
+    });
+
+    it("should include impact analysis", () => {
+      const system = refactorer.system;
+      expect(system).toContain("refactoring effects");
+      expect(system).toContain("system performance");
+      expect(system).toContain("functionality");
+    });
+
+    it("should specify surgical implementation", () => {
+      const system = refactorer.system;
+      expect(system).toContain("targeted improvements");
+      expect(system).toContain("minimal changes");
+    });
+
+    it("should include validation and testing", () => {
+      const system = refactorer.system;
+      expect(system).toContain("maintains existing behavior");
+    });
+
+    it("should specify consolidation phase", () => {
+      const system = refactorer.system;
+      expect(system).toContain("merge duplicate code");
+      expect(system).toContain("patterns");
+    });
+  });
+
+  describe("Refactoring Guidelines", () => {
+    it("should specify functionality preservation", () => {
+      const system = refactorer.system;
+      expect(system).toContain("preserve existing functionality");
+      expect(system).toContain("99.7% retention rate");
+    });
+
+    it("should emphasize gradual changes", () => {
+      const system = refactorer.system;
+      expect(system).toContain("gradual changes");
+      expect(system).toContain("minimize risk");
+    });
+
+    it("should focus on meaningful improvements", () => {
+      const system = refactorer.system;
+      expect(system).toContain("meaningful architectural improvements");
+    });
+
+    it("should require comprehensive validation", () => {
+      const system = refactorer.system;
+      expect(system).toContain("comprehensive testing");
+    });
+
+    it("should specify documentation requirements", () => {
+      const system = refactorer.system;
+      expect(system).toContain("Document refactoring rationale");
+      expect(system).toContain("benefits");
+    });
+  });
+
+  describe("Integration Points", () => {
+    it("should define comprehensive refactoring integration points", () => {
+      const system = refactorer.system;
+      expect(system).toContain("Integration Points");
+      expect(system).toContain("Code analysis and AST manipulation");
+      expect(system).toContain("Performance profiling");
+      expect(system).toContain("Automated testing");
+      expect(system).toContain("Code quality metrics");
+      expect(system).toContain("Version control");
+    });
+  });
+
+  describe("Tools Configuration", () => {
+    it("should have comprehensive refactoring tools", () => {
+      expect(refactorer.tools?.include).toContain("read");
+      expect(refactorer.tools?.include).toContain("grep");
+      expect(refactorer.tools?.include).toContain("lsp_*");
+      expect(refactorer.tools?.include).toContain("run_terminal_cmd");
+      expect(refactorer.tools?.include).toContain("ast_grep_search");
+      expect(refactorer.tools?.include).toContain("ast_grep_replace");
+      expect(refactorer.tools?.include).toContain("lsp_rename");
+      expect(refactorer.tools?.include).toContain("lsp_prepare_rename");
+    });
+
+    it("should have 8 refactoring-specific tools", () => {
+      expect(refactorer.tools?.include).toHaveLength(8);
+    });
+  });
+
+  describe("Permissions Configuration", () => {
+    it("should allow edit operations", () => {
+      expect(refactorer.permission?.edit).toBe("allow");
+    });
+
+    it("should have refactoring tool permissions", () => {
+      const bashPerms = refactorer.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("Refactoring Goal", () => {
+    it("should define clear refactoring maintenance goal", () => {
+      const system = refactorer.system;
+      expect(system).toContain("continuously improve code quality");
+      expect(system).toContain("maintainability");
+      expect(system).toContain("eliminating technical debt");
+      expect(system).toContain("systematic, validated refactoring");
+    });
+  });
+});

package/src/__tests__/agents/security-auditor.test.ts

@@ -0,0 +1,234 @@
+import { describe, it, expect } from "vitest";
+import { securityAuditor } from "../../agents/security-auditor.js";
+import type { AgentConfig } from "../../agents/types.js";
+
+describe("Security Auditor Agent Configuration", () => {
+  it("should be a valid AgentConfig object", () => {
+    const config: AgentConfig = securityAuditor;
+    expect(config).toBeDefined();
+  });
+
+  describe("Basic Configuration", () => {
+    it("should have correct name and model", () => {
+      expect(securityAuditor.name).toBe("security-auditor");
+      expect(securityAuditor.model).toBe("opencode/grok-code");
+    });
+
+    it("should be configured as subagent mode", () => {
+      expect(securityAuditor.mode).toBe("subagent");
+    });
+
+    it("should have low temperature for consistent security decisions", () => {
+      expect(securityAuditor.temperature).toBe(0.1);
+    });
+  });
+
+  describe("Description and System Prompt", () => {
+    it("should have appropriate security-focused description", () => {
+      expect(securityAuditor.description).toContain(
+        "StringRay Framework security auditor",
+      );
+      expect(securityAuditor.description).toContain("compliance monitoring");
+      expect(securityAuditor.description).toContain("vulnerability detection");
+    });
+
+    it("should have comprehensive security auditor system prompt", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("StringRay Security Auditor");
+      expect(system).toContain("comprehensive security validation");
+      expect(system).toContain("compliance monitoring");
+    });
+  });
+
+  describe("Core Responsibilities", () => {
+    it("should define 5 core security responsibilities", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("Vulnerability Detection");
+      expect(system).toContain("Compliance Monitoring");
+      expect(system).toContain("Threat Analysis");
+      expect(system).toContain("Security Validation");
+      expect(system).toContain("Audit Trail Management");
+    });
+
+    it("should specify vulnerability detection capabilities", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("Identify security vulnerabilities");
+      expect(system).toContain("potential attack vectors");
+    });
+
+    it("should include compliance monitoring focus", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("adherence to security standards");
+      expect(system).toContain("best practices");
+    });
+
+    it("should specify threat analysis responsibilities", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("systematic threat modeling");
+      expect(system).toContain("risk assessment");
+    });
+
+    it("should include audit trail management", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("comprehensive security audit logs");
+      expect(system).toContain("reporting");
+    });
+  });
+
+  describe("Key Facilities", () => {
+    it("should specify security-specific facilities", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("Key Facilities Available");
+      expect(system).toContain("Comprehensive logging");
+      expect(system).toContain("audit trails");
+      expect(system).toContain("sensitive data filtering");
+    });
+
+    it("should define security processor pipeline", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("Processor pipeline");
+      expect(system).toContain("securityPreValidate");
+      expect(system).toContain("vulnerabilityScan");
+      expect(system).toContain("threatAnalysis");
+      expect(system).toContain("securityCompliance");
+    });
+
+    it("should specify integration hooks", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("Integration hooks");
+      expect(system).toContain("pre/post security validation");
+      expect(system).toContain("threat monitoring");
+      expect(system).toContain("compliance tracking");
+    });
+
+    it("should mention security sandboxing", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("Security sandboxed execution");
+      expect(system).toContain("elevated permissions for security tools");
+    });
+
+    it("should include webhook endpoints", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("Webhook endpoints");
+      expect(system).toContain("security alerts");
+      expect(system).toContain("compliance notifications");
+    });
+  });
+
+  describe("Security Audit Process", () => {
+    it("should define 5-phase security audit process", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("Security Audit Process");
+      expect(system).toContain("Input Validation");
+      expect(system).toContain("Authentication & Authorization");
+      expect(system).toContain("Data Protection");
+      expect(system).toContain("Vulnerability Scanning");
+      expect(system).toContain("Compliance Verification");
+    });
+
+    it("should specify input validation requirements", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("all inputs are properly validated");
+      expect(system).toContain("sanitized");
+    });
+
+    it("should include authentication and authorization review", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("access controls");
+      expect(system).toContain("permission systems");
+    });
+
+    it("should specify data protection assessment", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("encryption");
+      expect(system).toContain("data handling");
+      expect(system).toContain("privacy compliance");
+    });
+  });
+
+  describe("Security Audit Guidelines", () => {
+    it("should specify security-by-design principles", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("security-by-design principles");
+    });
+
+    it("should reference zero-trust architecture", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("zero-trust architecture");
+    });
+
+    it("should reference OWASP Top 10", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("OWASP Top 10");
+    });
+
+    it("should specify actionable remediation", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("actionable remediation recommendations");
+    });
+
+    it("should emphasize audit trail maintenance", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("detailed audit trails");
+      expect(system).toContain("compliance");
+    });
+  });
+
+  describe("Integration Points", () => {
+    it("should define comprehensive security integration points", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("Integration Points");
+      expect(system).toContain("Vulnerability scanning tools");
+      expect(system).toContain("Compliance monitoring");
+      expect(system).toContain("Threat intelligence");
+      expect(system).toContain("Security information and event management");
+      expect(system).toContain("Automated remediation");
+    });
+  });
+
+  describe("Tools Configuration", () => {
+    it("should have security-focused tool permissions", () => {
+      expect(securityAuditor.tools?.include).toContain("read");
+      expect(securityAuditor.tools?.include).toContain("grep");
+      expect(securityAuditor.tools?.include).toContain("lsp_*");
+      expect(securityAuditor.tools?.include).toContain("run_terminal_cmd");
+      expect(securityAuditor.tools?.include).toContain("grep_app_searchGitHub");
+      expect(securityAuditor.tools?.include).toContain("webfetch");
+    });
+
+    it("should have 6 security-specific tools", () => {
+      expect(securityAuditor.tools?.include).toHaveLength(6);
+    });
+  });
+
+  describe("Permissions Configuration", () => {
+    it("should allow edit operations", () => {
+      expect(securityAuditor.permission?.edit).toBe("allow");
+    });
+
+    it("should have comprehensive bash permissions for security tools", () => {
+      const bashPerms = securityAuditor.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)?.security).toBe("allow");
+      expect((bashPerms as any)?.audit).toBe("allow");
+    });
+
+    it("should not have webfetch permissions defined", () => {
+      expect(securityAuditor.permission?.webfetch).toBeUndefined();
+    });
+  });
+
+  describe("Security Goal", () => {
+    it("should define clear security maintenance goal", () => {
+      const system = securityAuditor.system;
+      expect(system).toContain("maintain the highest levels of security");
+      expect(system).toContain("compliance");
+      expect(system).toContain("secure system operations");
+    });
+  });
+});