@crownpeak/dqm-react-component-dev-mcp 1.2.0

package/data/probe/npm/tests/delegate-config.test.js

@@ -0,0 +1,353 @@
+/**
+ * Configuration tests for delegate tool
+ * Tests the core functionality without mocking complex process spawning
+ */
+
+import { jest } from '@jest/globals';
+
+// Mock just the delegate function itself
+const mockDelegate = jest.fn();
+const mockIsDelegateAvailable = jest.fn(() => Promise.resolve(true));
+jest.unstable_mockModule('../src/delegate.js', () => ({
+  delegate: mockDelegate,
+  isDelegateAvailable: mockIsDelegateAvailable
+}));
+
+// Import after mocking
+const { delegateTool } = await import('../src/tools/vercel.js');
+const { ACPToolManager } = await import('../src/agent/acp/tools.js');
+
+describe('Delegate Tool Configuration', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockDelegate.mockResolvedValue('Mock delegate response');
+  });
+
+  describe('Vercel AI SDK Tool', () => {
+    it('should create delegate tool with correct configuration', () => {
+      const tool = delegateTool({ debug: true, timeout: 600 });
+      
+      expect(tool.name).toBe('delegate');
+      expect(tool.description).toContain('Automatically delegate');
+      expect(tool.description).toContain('agentic loop');
+      expect(tool.description).toContain('specialized probe subagents');
+      expect(tool.execute).toBeDefined();
+    });
+
+    it('should execute delegate tool with correct parameters', async () => {
+      const tool = delegateTool({ debug: true, timeout: 600 });
+      const task = 'Analyze security vulnerabilities in authentication code';
+
+      const result = await tool.execute({ task });
+
+      // Tool now passes all parameters including defaults
+      expect(mockDelegate).toHaveBeenCalledWith({
+        task,
+        timeout: 600,
+        debug: true,
+        currentIteration: 0,
+        maxIterations: 30,
+        parentSessionId: undefined,
+        path: undefined, // No cwd or allowedFolders configured
+        provider: undefined,
+        model: undefined,
+        tracer: undefined
+      });
+
+      expect(result).toBe('Mock delegate response');
+    });
+
+    it('should use cwd when path is not specified in call', async () => {
+      const tool = delegateTool({
+        debug: false,
+        timeout: 300,
+        cwd: '/project/workspace'
+      });
+      const task = 'Analyze code in workspace';
+
+      await tool.execute({ task });
+
+      expect(mockDelegate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          task,
+          path: '/project/workspace'
+        })
+      );
+    });
+
+    it('should use allowedFolders[0] when path and cwd are not specified', async () => {
+      const tool = delegateTool({
+        debug: false,
+        timeout: 300,
+        allowedFolders: ['/allowed/folder1', '/allowed/folder2']
+      });
+      const task = 'Search allowed folders';
+
+      await tool.execute({ task });
+
+      expect(mockDelegate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          task,
+          path: '/allowed/folder1'
+        })
+      );
+    });
+
+    it('should prioritize explicit path over cwd', async () => {
+      const tool = delegateTool({
+        debug: false,
+        timeout: 300,
+        cwd: '/default/path',
+        allowedFolders: ['/allowed/folder']
+      });
+      const task = 'Search specific path';
+
+      await tool.execute({ task, path: '/explicit/path' });
+
+      expect(mockDelegate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          task,
+          path: '/explicit/path'
+        })
+      );
+    });
+
+    it('should prioritize cwd over allowedFolders', async () => {
+      const tool = delegateTool({
+        debug: false,
+        timeout: 300,
+        cwd: '/default/path',
+        allowedFolders: ['/allowed/folder']
+      });
+      const task = 'Use cwd priority';
+
+      await tool.execute({ task });
+
+      expect(mockDelegate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          task,
+          path: '/default/path'
+        })
+      );
+    });
+
+    it('should handle execution errors gracefully', async () => {
+      const tool = delegateTool();
+      const task = 'Task that will fail';
+
+      mockDelegate.mockRejectedValue(new Error('Delegation process failed'));
+
+      // Tool now throws errors instead of returning error strings
+      await expect(tool.execute({ task })).rejects.toThrow('Delegation process failed');
+    });
+  });
+
+  describe('ACP Tool Manager Integration', () => {
+    let toolManager;
+    let mockServer;
+    let mockProbeAgent;
+
+    beforeEach(() => {
+      mockServer = {
+        options: { debug: true },
+        sendToolCallProgress: jest.fn()
+      };
+
+      mockProbeAgent = {
+        wrappedTools: {
+          delegateToolInstance: {
+            execute: jest.fn().mockResolvedValue('ACP delegate response')
+          }
+        },
+        sessionId: 'test-session-123'
+      };
+
+      toolManager = new ACPToolManager(mockServer, mockProbeAgent);
+    });
+
+    it('should classify delegate tool as execute kind', () => {
+      const toolKind = toolManager.getToolKind('delegate');
+      expect(toolKind).toBe('execute');
+    });
+
+    it('should execute delegate tool through ACP with lifecycle tracking', async () => {
+      const task = 'Review API security implementations';
+      
+      const result = await toolManager.executeToolCall('test-session', 'delegate', { task });
+      
+      expect(mockProbeAgent.wrappedTools.delegateToolInstance.execute).toHaveBeenCalledWith({
+        task,
+        sessionId: 'test-session-123'
+      });
+      
+      expect(mockServer.sendToolCallProgress).toHaveBeenCalledWith(
+        'test-session',
+        expect.any(String),
+        'pending'
+      );
+      
+      expect(mockServer.sendToolCallProgress).toHaveBeenCalledWith(
+        'test-session',
+        expect.any(String),
+        'completed',
+        'ACP delegate response'
+      );
+      
+      expect(result).toBe('ACP delegate response');
+    });
+
+    it('should provide delegate tool in definitions', () => {
+      const definitions = ACPToolManager.getToolDefinitions();
+      
+      const delegateTool = definitions.find(d => d.name === 'delegate');
+      expect(delegateTool).toBeDefined();
+      expect(delegateTool.kind).toBe('execute');
+      expect(delegateTool.description).toContain('Automatically delegate');
+      expect(delegateTool.inputSchema.properties.task).toBeDefined();
+      expect(delegateTool.inputSchema.required).toContain('task');
+    });
+  });
+
+  describe('XML Parsing and Agentic Usage', () => {
+    it('should support XML tool format for AI agents', () => {
+      const xmlExamples = [
+        '<delegate><task>Analyze authentication code for security vulnerabilities</task></delegate>',
+        '<delegate><task>Review database performance and optimization opportunities</task></delegate>',
+        '<delegate><task>Examine code structure and maintainability patterns</task></delegate>'
+      ];
+
+      xmlExamples.forEach(xml => {
+        expect(xml).toMatch(/<delegate>/);
+        expect(xml).toMatch(/<task>.*<\/task>/);
+        expect(xml).toMatch(/<\/delegate>/);
+        
+        // Extract task content
+        const taskMatch = xml.match(/<task>(.*?)<\/task>/);
+        expect(taskMatch).not.toBeNull();
+        expect(taskMatch[1].length).toBeGreaterThan(20);
+      });
+    });
+
+    it('should demonstrate proper task separation patterns', () => {
+      const complexRequest = 'Analyze my application for security, performance, and maintainability';
+      
+      const separatedTasks = [
+        'Analyze all authentication, authorization, and input validation code for security vulnerabilities',
+        'Review database queries, API endpoints, and resource usage for performance bottlenecks',
+        'Examine code structure, design patterns, and documentation for maintainability improvements'
+      ];
+
+      separatedTasks.forEach(task => {
+        expect(task.length).toBeGreaterThan(50);
+        expect(task).toMatch(/^(Analyze|Review|Examine)/);
+        
+        // Each task should focus on one domain
+        const domains = ['security', 'performance', 'maintainability'];
+        const matchedDomains = domains.filter(domain => 
+          task.toLowerCase().includes(domain) || 
+          (domain === 'security' && task.includes('vulnerabilities')) ||
+          (domain === 'performance' && task.includes('bottlenecks')) ||
+          (domain === 'maintainability' && task.includes('design patterns'))
+        );
+        
+        expect(matchedDomains.length).toBeGreaterThanOrEqual(1);
+      });
+    });
+
+    it('should validate task self-containment', () => {
+      const validTasks = [
+        'Find all SQL injection vulnerabilities in database queries and provide fix recommendations',
+        'Identify memory leaks and performance bottlenecks in async operations',
+        'Review error handling patterns and suggest improvements for better reliability'
+      ];
+
+      validTasks.forEach(task => {
+        // Should be actionable
+        expect(task).toMatch(/^(Find|Identify|Review|Analyze|Examine|Search)/);
+        
+        // Should be specific
+        expect(task.length).toBeGreaterThan(30);
+        expect(task.length).toBeLessThan(200);
+        
+        // Should not contain coordination words
+        expect(task).not.toMatch(/\band then\b|\bafter that\b|\balso\b/i);
+      });
+    });
+
+    it('should handle multi-line tasks in XML', () => {
+      const multilineTask = `Review database performance including:
+- Query optimization opportunities
+- Index usage patterns  
+- Connection pooling efficiency
+- N+1 query detection`;
+
+      const xml = `<delegate><task>${multilineTask}</task></delegate>`;
+      
+      expect(xml).toContain('Review database performance');
+      expect(xml).toContain('Query optimization');
+      expect(xml).toContain('N+1 query detection');
+      expect(xml).toMatch(/<delegate><task>[\s\S]*<\/task><\/delegate>/);
+    });
+  });
+
+  describe('Iteration Limit Logic', () => {
+    it('should test remaining iterations calculation', () => {
+      // Test the logic that would be used in the delegate function
+      const testCases = [
+        { current: 5, max: 20, expected: 15 },
+        { current: 25, max: 30, expected: 5 },
+        { current: 35, max: 30, expected: 1 }, // Should always allow at least 1
+        { current: 0, max: 10, expected: 10 }
+      ];
+
+      testCases.forEach(({ current, max, expected }) => {
+        const remaining = Math.max(1, max - current);
+        expect(remaining).toBe(expected);
+      });
+    });
+  });
+
+  describe('Tool Parameters and Schema', () => {
+    it('should validate delegate tool parameters', () => {
+      // Test parameter validation logic
+      const validTasks = [
+        'Analyze code for security issues',
+        'Find performance bottlenecks',
+        'Review error handling'
+      ];
+
+      validTasks.forEach(task => {
+        expect(typeof task).toBe('string');
+        expect(task.length).toBeGreaterThan(0);
+        expect(task.trim()).toBe(task); // No leading/trailing whitespace
+      });
+
+      // Test invalid parameters
+      const invalidTasks = [null, undefined, '', 123, {}, []];
+      
+      invalidTasks.forEach(task => {
+        expect(typeof task === 'string' && task.length > 0).toBe(false);
+      });
+    });
+
+    it('should have correct automatic flag configuration', () => {
+      // Test that automatic flags are properly defined
+      const expectedFlags = [
+        '--prompt-type', 'code-researcher',
+        '--no-schema-validation',
+        '--no-mermaid-validation'
+      ];
+
+      expectedFlags.forEach(flag => {
+        expect(typeof flag).toBe('string');
+        expect(flag.length).toBeGreaterThan(0);
+      });
+
+      // Verify flag patterns
+      expect('--prompt-type').toMatch(/^--[a-z-]+$/);
+      expect('code-researcher').toMatch(/^[a-z-]+$/);
+      expect('--no-schema-validation').toMatch(/^--no-[a-z-]+$/);
+      expect('--no-mermaid-validation').toMatch(/^--no-[a-z-]+$/);
+    });
+  });
+});

package/data/probe/npm/tests/delegate-integration.test.js

@@ -0,0 +1,348 @@
+/**
+ * Integration tests for delegate tool with Vercel AI SDK and ACP
+ */
+
+import { jest } from '@jest/globals';
+
+// Mock the delegate function
+const mockDelegate = jest.fn();
+const mockIsDelegateAvailable = jest.fn(() => Promise.resolve(true));
+jest.unstable_mockModule('../src/delegate.js', () => ({
+  delegate: mockDelegate,
+  isDelegateAvailable: mockIsDelegateAvailable
+}));
+
+// Mock ProbeAgent to avoid API key requirements
+const mockProbeAgent = jest.fn().mockImplementation((options) => {
+  const instance = {
+    sessionId: options.sessionId,
+    debug: options.debug,
+    maxIterations: options.maxIterations,
+    currentIteration: 0,
+    executeTool: jest.fn()
+  };
+  
+  instance.executeTool.mockImplementation(async (toolName, params) => {
+    if (toolName === 'delegate') {
+      // Simulate ProbeAgent calling delegate with iteration context
+      const enhancedParams = {
+        ...params,
+        currentIteration: instance.currentIteration,
+        maxIterations: instance.maxIterations,
+        debug: instance.debug
+      };
+      return await mockDelegate(enhancedParams);
+    }
+    return `Mock result for ${toolName}`;
+  });
+  
+  return instance;
+});
+jest.unstable_mockModule('../src/agent/ProbeAgent.js', () => ({
+  ProbeAgent: mockProbeAgent
+}));
+
+// Import after mocking
+const { delegateTool } = await import('../src/tools/vercel.js');
+const { ACPToolManager } = await import('../src/agent/acp/tools.js');
+const { ProbeAgent } = await import('../src/agent/ProbeAgent.js');
+
+describe('Delegate Tool Integration', () => {
+  describe('Vercel AI SDK Integration', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    afterEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('should create delegate tool with proper schema', () => {
+      const tool = delegateTool({ debug: true, timeout: 600 });
+      
+      expect(tool.name).toBe('delegate');
+      expect(tool.description).toContain('Automatically delegate');
+      expect(tool.description).toContain('agentic loop');
+      
+      // Zod schema should be an object
+      expect(tool.inputSchema).toBeDefined();
+      expect(typeof tool.inputSchema).toBe('object');
+
+      // Check that the schema can parse valid input
+      const validInput = { task: 'Test task' };
+      expect(() => tool.inputSchema.parse(validInput)).not.toThrow();
+
+      // Check that invalid input throws
+      expect(() => tool.inputSchema.parse({})).toThrow(); // Missing required task
+    });
+
+    it('should execute delegate tool with correct parameters', async () => {
+      const tool = delegateTool({ debug: true, timeout: 600 });
+      const task = 'Analyze security vulnerabilities in authentication code';
+
+      mockDelegate.mockResolvedValue('Security analysis complete: Found 3 vulnerabilities');
+
+      const result = await tool.execute({ task });
+
+      expect(mockDelegate).toHaveBeenCalledWith({
+        task,
+        timeout: 600,
+        debug: true,
+        currentIteration: 0,
+        maxIterations: 30,
+        parentSessionId: undefined,
+        path: undefined,
+        provider: undefined,
+        model: undefined,
+        tracer: undefined
+      });
+
+      expect(result).toBe('Security analysis complete: Found 3 vulnerabilities');
+    });
+
+    it('should handle delegate execution errors gracefully', async () => {
+      const tool = delegateTool();
+      const task = 'Invalid task that will fail';
+
+      mockDelegate.mockRejectedValue(new Error('Delegation process failed'));
+
+      // Tool now throws errors instead of returning error strings
+      await expect(tool.execute({ task })).rejects.toThrow('Delegation process failed');
+    });
+
+    it('should support XML parsing format', () => {
+      // Test that the tool definition supports XML parsing by AI agents
+      const tool = delegateTool();
+      
+      // Simulate AI agent parsing XML and converting to tool call
+      const xmlInput = '<delegate><task>Find all TODO comments in the codebase</task></delegate>';
+      const parsedTask = xmlInput.match(/<task>(.*?)<\/task>/s)?.[1];
+      
+      expect(parsedTask).toBe('Find all TODO comments in the codebase');
+      
+      // This would be how AI agent converts XML to tool call
+      const toolCall = {
+        name: tool.name,
+        arguments: { task: parsedTask }
+      };
+
+      expect(toolCall.name).toBe('delegate');
+      expect(toolCall.arguments.task).toBe('Find all TODO comments in the codebase');
+    });
+  });
+
+  describe('ACP Tool Manager Integration', () => {
+    let toolManager;
+    let mockServer;
+    let mockProbeAgent;
+    let mockDelegate;
+
+    beforeEach(async () => {
+      // Mock server
+      mockServer = {
+        options: { debug: true },
+        sendToolCallProgress: jest.fn()
+      };
+
+      // Mock probe agent with delegate tool
+      mockProbeAgent = {
+        wrappedTools: {
+          delegateToolInstance: {
+            execute: jest.fn()
+          }
+        },
+        sessionId: 'test-session-123'
+      };
+
+      toolManager = new ACPToolManager(mockServer, mockProbeAgent);
+
+      // Mock delegate function
+      const delegateModule = await import('../src/delegate.js');
+      mockDelegate = delegateModule.delegate;
+    });
+
+    afterEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('should execute delegate tool through ACP with proper lifecycle tracking', async () => {
+      const task = 'Review API security implementations';
+      const mockResponse = 'API security review completed';
+      
+      mockProbeAgent.wrappedTools.delegateToolInstance.execute.mockResolvedValue(mockResponse);
+      
+      const result = await toolManager.executeToolCall('test-session', 'delegate', { task });
+      
+      // Verify tool execution
+      expect(mockProbeAgent.wrappedTools.delegateToolInstance.execute).toHaveBeenCalledWith({
+        task,
+        sessionId: 'test-session-123'
+      });
+      
+      // Verify lifecycle notifications
+      expect(mockServer.sendToolCallProgress).toHaveBeenCalledWith(
+        'test-session',
+        expect.any(String),
+        'pending'
+      );
+      
+      expect(mockServer.sendToolCallProgress).toHaveBeenCalledWith(
+        'test-session',
+        expect.any(String),
+        'in_progress'
+      );
+      
+      expect(mockServer.sendToolCallProgress).toHaveBeenCalledWith(
+        'test-session',
+        expect.any(String),
+        'completed',
+        mockResponse
+      );
+      
+      expect(result).toBe(mockResponse);
+    });
+
+    it('should classify delegate tool as execute kind', () => {
+      const toolKind = toolManager.getToolKind('delegate');
+      expect(toolKind).toBe('execute');
+    });
+
+    it('should handle delegate tool failures with proper error reporting', async () => {
+      const task = 'Task that will fail';
+      const errorMessage = 'Delegation failed: Process terminated unexpectedly';
+      
+      mockProbeAgent.wrappedTools.delegateToolInstance.execute.mockRejectedValue(
+        new Error(errorMessage)
+      );
+      
+      await expect(
+        toolManager.executeToolCall('test-session', 'delegate', { task })
+      ).rejects.toThrow(errorMessage);
+      
+      // Verify error was reported through ACP
+      expect(mockServer.sendToolCallProgress).toHaveBeenCalledWith(
+        'test-session',
+        expect.any(String),
+        'failed',
+        null,
+        errorMessage
+      );
+    });
+  });
+
+  describe('ProbeAgent Integration', () => {
+    let probeAgent;
+    let mockDelegate;
+
+    beforeEach(async () => {
+      // Mock delegate function
+      const delegateModule = await import('../src/delegate.js');
+      mockDelegate = delegateModule.delegate;
+
+      // Create probe agent instance
+      probeAgent = new ProbeAgent({
+        sessionId: 'integration-test-session',
+        debug: true,
+        maxIterations: 25
+      });
+    });
+
+    afterEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('should pass iteration context to delegate tool execution', async () => {
+      const task = 'Complex task requiring delegation';
+      const expectedResponse = 'Task completed by subagent';
+      
+      mockDelegate.mockResolvedValue(expectedResponse);
+      
+      // Simulate some iterations have already occurred
+      probeAgent.currentIteration = 8;
+      
+      // Execute delegate tool through ProbeAgent
+      const result = await probeAgent.executeTool('delegate', { task });
+      
+      // Verify delegate was called with iteration context
+      expect(mockDelegate).toHaveBeenCalledWith({
+        task,
+        currentIteration: 8,
+        maxIterations: 25,
+        debug: true
+      });
+      
+      expect(result).toBe(expectedResponse);
+    });
+
+    it('should handle delegate tool when near iteration limit', async () => {
+      const task = 'Last minute delegation';
+      
+      mockDelegate.mockResolvedValue('Quick response from subagent');
+      
+      // Set current iteration very close to limit
+      probeAgent.currentIteration = 24;
+      probeAgent.maxIterations = 25;
+      
+      await probeAgent.executeTool('delegate', { task });
+      
+      // Should still allow delegation but with very limited iterations
+      expect(mockDelegate).toHaveBeenCalledWith({
+        task,
+        currentIteration: 24,
+        maxIterations: 25,
+        debug: true
+      });
+    });
+  });
+
+  // Note: Automatic flag verification is covered in delegate.test.js unit tests
+
+  describe('Agentic Loop Scenarios', () => {
+    it('should demonstrate multi-task delegation scenario', async () => {
+      // Simulate AI agent receiving complex request and breaking it down
+      const complexRequest = 'Analyze my Node.js application for security issues, performance problems, and code quality concerns';
+      
+      const expectedDelegations = [
+        'Analyze all input validation, authentication, authorization, and dependency vulnerabilities in the Node.js application',
+        'Review database queries, async operations, memory usage, and API response times for performance optimization opportunities',  
+        'Examine code structure, documentation, test coverage, and maintainability patterns across the application'
+      ];
+      
+      // Each delegation should be independent and focused
+      expectedDelegations.forEach(task => {
+        expect(task.length).toBeGreaterThan(50); // Substantial task
+        expect(task).not.toContain('and also'); // Single focus
+        
+        // Verify task is complete and actionable
+        if (task.includes('security') || task.includes('vulnerabilities')) {
+          expect(task).toMatch(/authentication|authorization|validation|vulnerabilities/);
+        } else if (task.includes('performance')) {
+          expect(task).toMatch(/database|async|memory|response|optimization/);
+        } else if (task.includes('quality') || task.includes('maintainability')) {
+          expect(task).toMatch(/structure|documentation|test|maintainability|patterns/);
+        }
+      });
+    });
+
+    it('should validate task self-containment for parallel execution', () => {
+      const tasks = [
+        'Find all SQL injection vulnerabilities in the database layer',
+        'Identify performance bottlenecks in the API endpoints',
+        'Review error handling patterns across all modules'
+      ];
+      
+      // Each task should be executable independently
+      tasks.forEach(task => {
+        // Should have clear scope and action
+        expect(task).toMatch(/^(Find|Identify|Review|Analyze|Examine)/);
+        
+        // Should specify domain clearly
+        expect(task).toMatch(/(vulnerabilities|bottlenecks|patterns|security|performance|error)/);
+        
+        // Should be specific enough to execute
+        expect(task.length).toBeGreaterThan(30);
+        expect(task.length).toBeLessThan(200);
+      });
+    });
+  });
+});