strray-ai 1.0.17 → 1.0.18

package/src/__tests__/integration/context-providers-integration.test.ts

@@ -0,0 +1,302 @@
+/**
+ * Integration tests for Context Providers Chain
+ * Tests the complete integration between CodebaseContextAnalyzer, ASTCodeParser, and DependencyGraphBuilder
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { AgentDelegator } from "../../delegation/agent-delegator.js";
+import { StringRayStateManager } from "../../state/state-manager.js";
+import { frameworkLogger } from "../../framework-logger.js";
+
+// Mock external dependencies
+vi.mock("../../framework-logger.js");
+
+describe("Context Providers Integration", () => {
+  let agentDelegator: AgentDelegator;
+  let stateManager: StringRayStateManager;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    stateManager = new StringRayStateManager();
+    agentDelegator = new AgentDelegator(stateManager);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("context provider initialization", () => {
+    it("should initialize all context providers successfully", () => {
+      expect(agentDelegator).toBeDefined();
+      // The constructor should have initialized context providers without throwing
+    });
+
+    it("should handle ast-grep unavailability gracefully", () => {
+      // Even if ast-grep is not available, the system should still initialize
+      expect(agentDelegator).toBeDefined();
+    });
+
+    it.skip("should log context provider initialization status", () => {
+      const mockLogger = vi.mocked(frameworkLogger);
+
+      // Constructor should have called logger
+      expect(mockLogger.log).toHaveBeenCalledWith(
+        "agent-delegator",
+        "context-providers-initialized",
+        "success",
+        expect.any(Object),
+      );
+    });
+  });
+
+  describe("complexity analysis with context awareness", () => {
+    it("should enhance complexity analysis with context data", async () => {
+      const request = {
+        operation: "analyze-component",
+        description: "Analyze a React component with dependencies",
+        context: {
+          files: ["src/components/Button.tsx", "src/utils/helpers.ts"],
+          filePath: "src/components/Button.tsx",
+          operation: "refactor",
+        },
+      };
+
+      const result = await agentDelegator.analyzeDelegation(request);
+
+      expect(result.strategy).toBeDefined();
+      expect(result.complexity.score).toBeGreaterThanOrEqual(0);
+      expect(result.complexity.level).toBeDefined();
+      expect(result.agents).toBeDefined();
+      expect(result.agents.length).toBeGreaterThan(0);
+    });
+
+    it.skip("should use context-enhanced metrics for large codebases", async () => {
+      const request = {
+        operation: "refactor-large-component",
+        description: "Refactor a large component with many dependencies",
+        context: {
+          files: Array.from({ length: 100 }, (_, i) => `src/component${i}.tsx`),
+          filePath: "src/components/LargeComponent.tsx",
+          operation: "refactor",
+        },
+      };
+
+      const result = await agentDelegator.analyzeDelegation(request);
+
+      expect(result.complexity.level).toBe("enterprise");
+      expect(result.strategy).toBe("orchestrator-led");
+      expect(result.agents.length).toBeGreaterThan(2);
+    });
+
+    it("should fall back to basic metrics when context analysis fails", async () => {
+      // This test verifies that even if context providers have issues,
+      // the system continues to work with basic complexity analysis
+
+      const request = {
+        operation: "simple-function",
+        description: "Simple function that should work with basic analysis",
+        context: {
+          files: ["simple.ts"],
+          operation: "create",
+        },
+      };
+
+      const result = await agentDelegator.analyzeDelegation(request);
+
+      expect(result.strategy).toBeDefined();
+      expect(result.complexity.score).toBeGreaterThanOrEqual(0);
+      // Should still work even if context enhancement fails
+    });
+  });
+
+  describe("memory optimization integration", () => {
+    it("should respect memory limits during analysis", async () => {
+      const request = {
+        operation: "analyze-large-codebase",
+        description: "Analyze large codebase with memory constraints",
+        context: {
+          files: Array.from({ length: 200 }, (_, i) => `src/file${i}.ts`),
+          filePath: "src/main.ts",
+          operation: "analyze",
+        },
+      };
+
+      const result = await agentDelegator.analyzeDelegation(request);
+
+      expect(result).toBeDefined();
+      // Should complete analysis even with memory constraints
+    });
+
+    it("should cache analysis results appropriately", async () => {
+      const request1 = {
+        operation: "analyze-component",
+        description: "First analysis of component",
+        context: {
+          files: ["src/Button.tsx"],
+          filePath: "src/Button.tsx",
+        },
+      };
+
+      const request2 = {
+        operation: "analyze-component",
+        description: "Second analysis of same component",
+        context: {
+          files: ["src/Button.tsx"],
+          filePath: "src/Button.tsx",
+        },
+      };
+
+      await agentDelegator.analyzeDelegation(request1);
+      await agentDelegator.analyzeDelegation(request2);
+
+      // Both should complete successfully, potentially using cached results
+      expect(true).toBe(true);
+    });
+  });
+
+  describe("error handling and resilience", () => {
+    it("should handle context provider initialization failures", () => {
+      // The system should be resilient to context provider issues
+      // This is already tested by the constructor tests above
+      expect(agentDelegator).toBeDefined();
+    });
+
+    it("should continue operating with partial context data", async () => {
+      const request = {
+        operation: "analyze-with-limited-context",
+        description: "Analysis with minimal context data",
+        context: {
+          // Minimal context that might cause some providers to fail
+          files: ["unknown-file.xyz"],
+          operation: "unknown",
+        },
+      };
+
+      const result = await agentDelegator.analyzeDelegation(request);
+
+      // Should still produce a valid result
+      expect(result.strategy).toBeDefined();
+      expect(result.complexity.score).toBeGreaterThanOrEqual(0);
+    });
+
+    it("should log errors without crashing the analysis", async () => {
+      const mockLogger = vi.mocked(frameworkLogger);
+
+      const request = {
+        operation: "problematic-analysis",
+        description: "Analysis that might cause issues",
+        context: {
+          files: ["nonexistent-file.ts"],
+          filePath: "nonexistent-file.ts",
+        },
+      };
+
+      await agentDelegator.analyzeDelegation(request);
+
+      // Should have logged any errors but not thrown
+      expect(mockLogger.log).toHaveBeenCalled();
+    });
+  });
+
+  describe("performance validation", () => {
+    it("should complete analysis within reasonable time limits", async () => {
+      const request = {
+        operation: "performance-test",
+        description: "Test analysis performance",
+        context: {
+          files: ["src/test.ts"],
+          filePath: "src/test.ts",
+          operation: "create",
+        },
+      };
+
+      const startTime = Date.now();
+      const result = await agentDelegator.analyzeDelegation(request);
+      const duration = Date.now() - startTime;
+
+      expect(duration).toBeLessThan(5000); // Should complete within 5 seconds
+      expect(result).toBeDefined();
+    });
+
+    it("should handle concurrent analysis requests", async () => {
+      const requests = Array.from({ length: 5 }, (_, i) => ({
+        operation: `concurrent-test-${i}`,
+        description: `Concurrent analysis request ${i}`,
+        context: {
+          files: [`src/test${i}.ts`],
+          filePath: `src/test${i}.ts`,
+          operation: "create",
+        },
+      }));
+
+      const startTime = Date.now();
+      const results = await Promise.all(
+        requests.map((request) => agentDelegator.analyzeDelegation(request)),
+      );
+      const duration = Date.now() - startTime;
+
+      expect(results).toHaveLength(5);
+      results.forEach((result) => {
+        expect(result.strategy).toBeDefined();
+        expect(result.complexity.score).toBeGreaterThanOrEqual(0);
+      });
+
+      expect(duration).toBeLessThan(10000); // Should complete within 10 seconds for 5 concurrent requests
+    });
+  });
+
+  describe("rule enforcement integration", () => {
+    it("should apply complexity-based agent selection rules", async () => {
+      const simpleRequest = {
+        operation: "create-simple-component",
+        description: "Simple component creation",
+        context: {
+          files: ["src/SimpleButton.tsx"],
+          operation: "create",
+        },
+      };
+
+      const complexRequest = {
+        operation: "refactor-large-system",
+        description: "Complex system refactoring",
+        context: {
+          files: Array.from({ length: 100 }, (_, i) => `src/component${i}.tsx`),
+          operation: "refactor",
+          riskLevel: "critical" as const,
+        },
+      };
+
+      const simpleResult =
+        await agentDelegator.analyzeDelegation(simpleRequest);
+      const complexResult =
+        await agentDelegator.analyzeDelegation(complexRequest);
+
+      // Simple request should use fewer agents
+      expect(simpleResult.agents.length).toBeLessThanOrEqual(
+        complexResult.agents.length,
+      );
+      expect(simpleResult.strategy).not.toBe("orchestrator-led");
+
+      // Complex request should use more sophisticated strategy
+      expect(complexResult.strategy).toBe("orchestrator-led");
+    });
+
+    it("should enforce memory limits during analysis", async () => {
+      const largeRequest = {
+        operation: "analyze-massive-codebase",
+        description: "Analysis of very large codebase",
+        context: {
+          files: Array.from({ length: 1000 }, (_, i) => `src/file${i}.ts`),
+          filePath: "src/main.ts",
+          operation: "analyze",
+        },
+      };
+
+      const result = await agentDelegator.analyzeDelegation(largeRequest);
+
+      // Should complete analysis despite large input
+      expect(result).toBeDefined();
+      expect(result.complexity.score).toBeGreaterThanOrEqual(0);
+    });
+  });
+});

package/src/__tests__/integration/delegation-system.test.ts

@@ -0,0 +1,263 @@
+/**
+ * StringRay AI v1.0.9 - Delegation System Integration Tests
+ *
+ * Tests the complete automatic multi-agent delegation system.
+ *
+ * @version 1.0.0
+ * @since 2026-01-07
+ */
+
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { StringRayStateManager } from "../../state/state-manager.js";
+import {
+  createAgentDelegator,
+  createSessionCoordinator,
+} from "../../delegation/index.js";
+
+describe("StringRay Delegation System Integration", () => {
+  let stateManager: StringRayStateManager;
+  let agentDelegator: any;
+  let sessionCoordinator: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    stateManager = new StringRayStateManager();
+    agentDelegator = createAgentDelegator(stateManager);
+    sessionCoordinator = createSessionCoordinator(stateManager);
+
+    // Register mock agents for testing
+    const mockAgent = {
+      execute: vi.fn().mockImplementation(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 1)); // Small delay to ensure duration > 0
+        return { result: "success" };
+      }),
+      getCapabilities: vi
+        .fn()
+        .mockReturnValue({ name: "test-architect", performance: 0.8 }),
+    };
+    stateManager.set("agent:test-architect", mockAgent);
+    stateManager.set("agent:enforcer", mockAgent);
+    stateManager.set("agent:architect", mockAgent);
+    stateManager.set("agent:security-auditor", mockAgent);
+  });
+
+  describe("Session Management", () => {
+    it("should initialize session with proper metadata", () => {
+      const session = sessionCoordinator.initializeSession("test_session");
+
+      expect(session).toBeDefined();
+      expect(session.sessionId).toBe("test_session");
+      expect(session.createdAt).toBeInstanceOf(Date);
+      expect(session.agentCount).toBeGreaterThan(0);
+    });
+
+    it("should track session status correctly", () => {
+      sessionCoordinator.initializeSession("status_test");
+
+      const status = sessionCoordinator.getSessionStatus("status_test");
+      expect(status).toBeDefined();
+      expect(status.active).toBe(true);
+      expect(status.agentCount).toBeGreaterThan(0);
+    });
+
+    it("should cleanup session properly", () => {
+      sessionCoordinator.initializeSession("cleanup_test");
+      sessionCoordinator.cleanupSession("cleanup_test");
+
+      const status = sessionCoordinator.getSessionStatus("cleanup_test");
+      expect(status).toBeNull(); // Session should be completely removed after cleanup
+    });
+  });
+
+  describe("Complexity Analysis", () => {
+    it("should analyze simple operations correctly", async () => {
+      const request = {
+        operation: "format",
+        description: "Format a single file",
+        context: {
+          files: ["utils.ts"],
+          changeVolume: 10,
+          dependencies: 0,
+          riskLevel: "low" as const,
+        },
+      };
+
+      const delegation = await agentDelegator.analyzeDelegation(request);
+
+      expect(delegation.complexity.level).toBe("simple");
+      expect(delegation.strategy).toBe("single-agent");
+      expect(delegation.agents).toHaveLength(1);
+    });
+
+    it("should analyze complex operations correctly", async () => {
+      const request = {
+        operation: "refactor",
+        description: "Refactor complex authentication module",
+        context: {
+          files: ["auth.ts", "user.ts", "permissions.ts", "database.ts"],
+          changeVolume: 500,
+          dependencies: 8,
+          riskLevel: "high" as const,
+        },
+      };
+
+      const delegation = await agentDelegator.analyzeDelegation(request);
+
+      expect(delegation.complexity.level).toBe("complex");
+      expect(delegation.strategy).toBe("multi-agent");
+      expect(delegation.agents.length).toBeGreaterThan(1);
+    });
+  });
+
+  describe("Agent Coordination", () => {
+    it("should send and receive messages between agents", async () => {
+      const session = sessionCoordinator.initializeSession("msg_test");
+
+      await sessionCoordinator.sendMessage(
+        session.sessionId,
+        "architect",
+        "enforcer",
+        {
+          type: "design_review",
+          data: "Please review the architectural changes",
+        },
+      );
+
+      const messages = sessionCoordinator.receiveMessages(
+        session.sessionId,
+        "enforcer",
+      );
+      expect(messages).toHaveLength(1);
+      expect(messages[0].message.type).toBe("design_review");
+    });
+
+    it("should share and retrieve context data", async () => {
+      const session = sessionCoordinator.initializeSession("context_test");
+
+      sessionCoordinator.shareContext(
+        session.sessionId,
+        "design_decisions",
+        {
+          pattern: "observer",
+          reasoning: "For loose coupling between auth components",
+        },
+        "architect",
+      );
+
+      const sharedData = sessionCoordinator.getSharedContext(
+        session.sessionId,
+        "design_decisions",
+      );
+      expect(sharedData).toBeDefined();
+      expect(sharedData!.pattern).toBe("observer");
+      expect(sharedData!.sharedBy).toBe("architect");
+    });
+  });
+
+  describe("Conflict Resolution", () => {
+    it("should resolve conflicts using majority vote", async () => {
+      const session = sessionCoordinator.initializeSession("conflict_test");
+
+      // Simulate conflicting recommendations
+      sessionCoordinator.shareContext(
+        session.sessionId,
+        "recommendation",
+        "Option A",
+        "architect",
+      );
+      sessionCoordinator.shareContext(
+        session.sessionId,
+        "recommendation",
+        "Option A",
+        "enforcer",
+      );
+      sessionCoordinator.shareContext(
+        session.sessionId,
+        "recommendation",
+        "Option B",
+        "refactorer",
+      );
+
+      const resolved = sessionCoordinator.resolveConflict(
+        session.sessionId,
+        "recommendation",
+        "majority_vote",
+      );
+      expect(resolved).toBe("Option A");
+    });
+
+    it("should resolve conflicts using expert priority", async () => {
+      const session = sessionCoordinator.initializeSession("expert_test");
+
+      sessionCoordinator.shareContext(
+        session.sessionId,
+        "security_review",
+        "Approved",
+        "security-auditor",
+      );
+      sessionCoordinator.shareContext(
+        session.sessionId,
+        "security_review",
+        "Rejected",
+        "architect",
+      );
+
+      const resolved = sessionCoordinator.resolveConflict(
+        session.sessionId,
+        "security_review",
+        "expert_priority",
+      );
+      expect(resolved).toBe("Approved"); // Security expert takes priority
+    });
+  });
+
+  describe("Performance and Monitoring", () => {
+    it("should track delegation performance metrics", async () => {
+      const request = {
+        operation: "test",
+        description: "Performance test",
+        context: {
+          files: ["test.ts"],
+          changeVolume: 50,
+          dependencies: 2,
+          riskLevel: "medium" as const,
+        },
+      };
+
+      const startTime = Date.now();
+
+      // Analyze and then execute the delegation to generate performance metrics
+      const delegation = await agentDelegator.analyzeDelegation(request);
+      await agentDelegator.executeDelegation(delegation, request);
+
+      const endTime = Date.now();
+
+      const metrics = agentDelegator.getPerformanceMetrics();
+      expect(metrics.totalDelegations).toBeGreaterThan(0);
+      expect(metrics.averageResponseTime).toBeGreaterThan(0);
+      expect(endTime - startTime).toBeLessThan(2000); // Should complete within reasonable time
+    });
+
+    it("should maintain session performance under load", () => {
+      // Create multiple sessions
+      for (let i = 0; i < 10; i++) {
+        sessionCoordinator.initializeSession(`perf_test_${i}`);
+      }
+
+      // All sessions should be active
+      for (let i = 0; i < 10; i++) {
+        const status = sessionCoordinator.getSessionStatus(`perf_test_${i}`);
+        expect(status.active).toBe(true);
+      }
+
+      // Cleanup should work efficiently
+      const cleanupStart = Date.now();
+      for (let i = 0; i < 10; i++) {
+        sessionCoordinator.cleanupSession(`perf_test_${i}`);
+      }
+      const cleanupTime = Date.now() - cleanupStart;
+
+      expect(cleanupTime).toBeLessThan(100); // Should cleanup quickly
+    });
+  });
+});