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

package/data/probe/npm/tests/unit/maxIterationsWarning.test.js

@@ -0,0 +1,195 @@
+/**
+ * Unit tests for max tool iterations warning logic
+ * Tests the core warning message functionality without full ProbeAgent integration
+ */
+
+import { describe, test, expect } from '@jest/globals';
+
+describe('Max Tool Iterations Warning Logic', () => {
+  
+  // Test the core warning message generation logic
+  describe('Warning Message Generation', () => {
+    test('should generate correct warning message format', () => {
+      const maxIterations = 30;
+      const warningMessage = `⚠️ WARNING: You have reached the maximum tool iterations limit (${maxIterations}). This is your final message. Please respond with the data you have so far. If something was not completed, honestly state what was not done and provide any partial results or recommendations you can offer.`;
+      
+      // Verify the warning message contains all required elements
+      expect(warningMessage).toContain('⚠️ WARNING');
+      expect(warningMessage).toContain('maximum tool iterations limit');
+      expect(warningMessage).toContain(`(${maxIterations})`);
+      expect(warningMessage).toContain('This is your final message');
+      expect(warningMessage).toContain('honestly state what was not done');
+      expect(warningMessage).toContain('partial results or recommendations');
+    });
+
+    test('should include different iteration limits in message', () => {
+      const testLimits = [1, 5, 10, 30, 50, 100];
+      
+      testLimits.forEach(limit => {
+        const warningMessage = `⚠️ WARNING: You have reached the maximum tool iterations limit (${limit}). This is your final message. Please respond with the data you have so far. If something was not completed, honestly state what was not done and provide any partial results or recommendations you can offer.`;
+        
+        expect(warningMessage).toContain(`limit (${limit})`);
+      });
+    });
+  });
+
+  describe('Iteration Counting Logic', () => {
+    test('should detect when current iteration equals max iterations', () => {
+      // Test different scenarios
+      const testCases = [
+        { current: 1, max: 1, shouldWarn: true },
+        { current: 5, max: 5, shouldWarn: true },
+        { current: 30, max: 30, shouldWarn: true },
+        { current: 1, max: 5, shouldWarn: false },
+        { current: 4, max: 5, shouldWarn: false },
+        { current: 29, max: 30, shouldWarn: false }
+      ];
+
+      testCases.forEach(({ current, max, shouldWarn }) => {
+        const shouldShowWarning = (current === max);
+        expect(shouldShowWarning).toBe(shouldWarn);
+      });
+    });
+
+    test('should handle schema-extended iteration limits', () => {
+      const baseLimit = 30;
+      const schemaExtension = 4;
+      const extendedLimit = baseLimit + schemaExtension;
+      
+      // When schema is provided, limit should be extended
+      expect(extendedLimit).toBe(34);
+      
+      // Warning should trigger at the extended limit
+      const shouldWarnAtBase = (baseLimit === baseLimit); // true
+      const shouldWarnAtExtended = (extendedLimit === extendedLimit); // true
+      
+      expect(shouldWarnAtBase).toBe(true);
+      expect(shouldWarnAtExtended).toBe(true);
+    });
+  });
+
+  describe('Environment Variable Handling', () => {
+    test('should parse MAX_TOOL_ITERATIONS environment variable correctly', () => {
+      // Test parsing logic (simulating how the actual code works)
+      const testCases = [
+        { env: '30', expected: 30 },
+        { env: '1', expected: 1 },
+        { env: '100', expected: 100 },
+        { env: undefined, expected: 30 }, // default
+        { env: '', expected: 30 }, // default
+        { env: 'invalid', expected: NaN }
+      ];
+
+      testCases.forEach(({ env, expected }) => {
+        const parsed = parseInt(env || '30', 10);
+        if (isNaN(expected)) {
+          expect(isNaN(parsed)).toBe(true);
+        } else {
+          expect(parsed).toBe(expected);
+        }
+      });
+    });
+  });
+
+  describe('Message Structure Validation', () => {
+    test('should create proper message structure for AI model', () => {
+      const maxIterations = 25;
+      const warningMessage = `⚠️ WARNING: You have reached the maximum tool iterations limit (${maxIterations}). This is your final message. Please respond with the data you have so far. If something was not completed, honestly state what was not done and provide any partial results or recommendations you can offer.`;
+      
+      // Simulate the message structure that would be added to the conversation
+      const messageStructure = {
+        role: 'user',
+        content: warningMessage
+      };
+      
+      expect(messageStructure.role).toBe('user');
+      expect(messageStructure.content).toBe(warningMessage);
+      expect(typeof messageStructure.content).toBe('string');
+      expect(messageStructure.content.length).toBeGreaterThan(0);
+    });
+
+    test('should ensure warning message is clear and actionable', () => {
+      const warningMessage = `⚠️ WARNING: You have reached the maximum tool iterations limit (30). This is your final message. Please respond with the data you have so far. If something was not completed, honestly state what was not done and provide any partial results or recommendations you can offer.`;
+      
+      // Check that the message contains actionable instructions
+      const actionableKeywords = [
+        'respond with the data',
+        'honestly state',
+        'what was not done',
+        'partial results',
+        'recommendations'
+      ];
+
+      actionableKeywords.forEach(keyword => {
+        expect(warningMessage.toLowerCase()).toContain(keyword.toLowerCase());
+      });
+    });
+
+    test('should handle different iteration limit scenarios', () => {
+      // Test edge cases
+      const edgeCases = [
+        { limit: 1, description: 'minimum limit' },
+        { limit: 2, description: 'very low limit' }, 
+        { limit: 30, description: 'default limit' },
+        { limit: 100, description: 'high limit' }
+      ];
+
+      edgeCases.forEach(({ limit, description }) => {
+        const warningMessage = `⚠️ WARNING: You have reached the maximum tool iterations limit (${limit}). This is your final message. Please respond with the data you have so far. If something was not completed, honestly state what was not done and provide any partial results or recommendations you can offer.`;
+        
+        expect(warningMessage).toContain(`limit (${limit})`);
+        expect(warningMessage).toContain('This is your final message');
+        
+        // Message should be consistent regardless of limit value
+        expect(warningMessage.split(' ').length).toBeGreaterThan(20); // Reasonable message length
+      });
+    });
+  });
+
+  describe('Integration Points', () => {
+    test('should verify warning triggers at the right time in iteration flow', () => {
+      // Simulate the iteration loop logic
+      const MAX_ITERATIONS = 3;
+      let currentIteration = 0;
+      const warningTriggered = [];
+
+      // Simulate 5 iterations
+      for (let i = 0; i < 5; i++) {
+        currentIteration++;
+        
+        // Check if warning should be triggered (this is the actual logic from the code)
+        if (currentIteration === MAX_ITERATIONS) {
+          warningTriggered.push(currentIteration);
+        }
+        
+        // Break if we would exceed max iterations (simulating the while loop condition)
+        if (currentIteration >= MAX_ITERATIONS) {
+          break;
+        }
+      }
+
+      // Warning should be triggered exactly once at iteration 3
+      expect(warningTriggered).toHaveLength(1);
+      expect(warningTriggered[0]).toBe(MAX_ITERATIONS);
+      expect(currentIteration).toBe(MAX_ITERATIONS);
+    });
+
+    test('should handle schema option extension correctly', () => {
+      const BASE_LIMIT = 5;
+      const SCHEMA_EXTENSION = 4;
+      
+      // Test without schema
+      const normalLimit = BASE_LIMIT;
+      expect(normalLimit).toBe(5);
+      
+      // Test with schema (logic from actual code)
+      const hasSchema = true;
+      const extendedLimit = hasSchema ? BASE_LIMIT + SCHEMA_EXTENSION : BASE_LIMIT;
+      expect(extendedLimit).toBe(9);
+      
+      // Warning should trigger at different points
+      expect(5 === normalLimit).toBe(true); // Would trigger at iteration 5 normally
+      expect(9 === extendedLimit).toBe(true); // Would trigger at iteration 9 with schema
+    });
+  });
+});

package/data/probe/npm/tests/unit/mermaidEdgeLabelFix.test.js

@@ -0,0 +1,161 @@
+/**
+ * Unit tests for Mermaid edge label syntax fixing
+ *
+ * Tests that MermaidFixingAgent correctly instructs AI to use pipe syntax
+ * for edge labels instead of double quotes, preventing validation loops.
+ */
+
+import { describe, test, expect, jest } from '@jest/globals';
+import { validateMermaidDiagram } from '../../src/agent/schemaUtils.js';
+
+// Dynamically import MermaidFixingAgent to avoid circular dependency
+const { MermaidFixingAgent } = await import('../../src/agent/schemaUtils.js');
+
+describe('Mermaid Edge Label Syntax Fixing', () => {
+  test('should detect invalid edge labels with double quotes', async () => {
+    const invalidDiagrams = [
+      'graph TD\n    A -- "Label Text" --> B',
+      'graph TD\n    E -- "JSON-RPC Messages ONLY" --> F[stdout]',
+      'flowchart LR\n    X -- "Step 1" --> Y\n    Y -- "Step 2" --> Z'
+    ];
+
+    for (const diagram of invalidDiagrams) {
+      const result = await validateMermaidDiagram(diagram);
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBeDefined();
+    }
+  });
+
+  test('should validate edge labels with pipe syntax', async () => {
+    const validDiagrams = [
+      { desc: 'dashes with pipes', diagram: 'graph TD\n    A --|Label Text|--> B' },
+      { desc: 'dashes with spaced pipes', diagram: 'graph TD\n    A -- |Label Text| --> B' },
+      { desc: 'arrow with spaced pipes', diagram: 'graph TD\n    A -->|Label Text| B' },
+      { desc: 'complex label', diagram: 'graph TD\n    E --|JSON-RPC Messages ONLY|--> F[stdout]' },
+      { desc: 'multiple edges', diagram: 'flowchart LR\n    X --|Step 1|--> Y\n    Y --|Step 2|--> Z' }
+    ];
+
+    for (const { desc, diagram } of validDiagrams) {
+      const result = await validateMermaidDiagram(diagram);
+      expect(result.isValid).toBe(true);
+      expect(result.diagramType).toBe('flowchart');
+    }
+  });
+
+  test('MermaidFixingAgent prompt should include edge label syntax rules', async () => {
+    const fixer = new MermaidFixingAgent({ debug: false });
+    const prompt = fixer.getMermaidFixingPrompt();
+
+    // Verify prompt instructs to use pipe syntax
+    expect(prompt).toContain('Edge/Arrow labels');
+    expect(prompt).toContain('pipe syntax');
+    expect(prompt).toContain('--|');
+    expect(prompt).toContain('NEVER use double quotes');
+  });
+
+  test('should fix invalid edge labels using mocked AI', async () => {
+    // Create mock AI that returns corrected diagram with pipe syntax
+    const invalidDiagram = `graph TD
+    A[Start]
+    A -- "Invalid Label 1" --> B[Process]
+    B -- "Invalid Label 2" --> C[End]`;
+
+    const fixedDiagram = `graph TD
+    A[Start]
+    A -->|Invalid Label 1| B[Process]
+    B -->|Invalid Label 2| C[End]`;
+
+    // Mock ProbeAgent.answer to return fixed diagram
+    const mockAgent = {
+      answer: jest.fn().mockResolvedValue(`\`\`\`mermaid\n${fixedDiagram}\n\`\`\``)
+    };
+
+    // Create MermaidFixingAgent and inject mock
+    const fixer = new MermaidFixingAgent({ debug: false });
+    await fixer.initializeAgent();
+    fixer.agent = mockAgent;
+
+    // Verify original diagram is invalid
+    const validationBefore = await validateMermaidDiagram(invalidDiagram);
+    expect(validationBefore.isValid).toBe(false);
+
+    // Trigger the fixing flow
+    const errors = ['line 4:14: Expecting token sequences, but found: "JSON-RPC Messages ONLY"'];
+    const result = await fixer.fixMermaidDiagram(invalidDiagram, errors, {});
+
+
+    // Verify the fix - result should have pipe syntax
+    expect(result).toContain('-->|Invalid Label 1|');
+    expect(result).toContain('-->|Invalid Label 2|');
+    expect(result).not.toContain('"Invalid Label 1"');
+    expect(result).not.toContain('"Invalid Label 2"');
+
+    // Verify the AI was called with correct prompt
+    expect(mockAgent.answer).toHaveBeenCalled();
+    const callArgs = mockAgent.answer.mock.calls[0];
+    expect(callArgs[0]).toContain('Analyze and fix');
+    expect(callArgs[0]).toContain('Mermaid diagram');
+
+    // Verify no schema parameter (this was causing the loop)
+    if (callArgs.length >= 3) {
+      expect(callArgs[2]).not.toHaveProperty('schema');
+    }
+
+    // Verify fixed diagram is valid
+    const validationAfter = await validateMermaidDiagram(result);
+    if (!validationAfter.isValid) {
+      throw new Error(`Fixed diagram validation failed: ${validationAfter.error}\nResult: ${result}`);
+    }
+    expect(validationAfter.isValid).toBe(true);
+  });
+
+  test('should not fix already valid edge labels', async () => {
+    const validDiagram = `graph TD
+    A --|Label Text|--> B
+    B --|Another Label|--> C`;
+
+    const validation = await validateMermaidDiagram(validDiagram);
+    expect(validation.isValid).toBe(true);
+    expect(validation.diagramType).toBe('flowchart');
+  });
+
+  test('should handle mixed valid and invalid edge labels', async () => {
+    const mixedDiagram = `graph TD
+    A --|Valid Label|--> B
+    B -- "Invalid Label" --> C`;
+
+    const result = await validateMermaidDiagram(mixedDiagram);
+    expect(result.isValid).toBe(false);
+    expect(result.error).toBeDefined();
+  });
+
+  test('MermaidFixingAgent should not loop infinitely', async () => {
+    // Mock AI that returns a fixed diagram (this test ensures the flow completes)
+    const mockAgent = {
+      answer: jest.fn().mockResolvedValue('```mermaid\ngraph TD\n    A -->|Fixed Label| B\n```')
+    };
+
+    const fixer = new MermaidFixingAgent({ debug: false });
+    await fixer.initializeAgent();
+    fixer.agent = mockAgent;
+
+    const invalidDiagram = 'graph TD\n    A -- "Invalid" --> B';
+
+    // This should complete without looping
+    const result = await fixer.fixMermaidDiagram(invalidDiagram, ['Invalid syntax'], {});
+
+    // Verify AI was only called once (not in infinite loop)
+    expect(mockAgent.answer).toHaveBeenCalledTimes(1);
+    expect(result).toContain('-->|Fixed Label|');
+  });
+
+  test('MermaidFixingAgent should disable mermaid validation in nested ProbeAgent', async () => {
+    // This test verifies the fix for the infinite recursion bug
+    // The inner ProbeAgent used by MermaidFixingAgent must have disableMermaidValidation=true
+    const fixer = new MermaidFixingAgent({ debug: false });
+    await fixer.initializeAgent();
+
+    // Verify the nested ProbeAgent has mermaid validation disabled
+    expect(fixer.agent.disableMermaidValidation).toBe(true);
+  });
+});

package/data/probe/npm/tests/unit/mermaidHtmlEntities.test.js

@@ -0,0 +1,76 @@
+import { jest, describe, it, expect } from '@jest/globals';
+import { validateMermaidDiagram } from '../../src/agent/schemaUtils.js';
+
+describe('Mermaid HTML Entities Support', () => {
+  it('should accept HTML entities in node labels as valid', async () => {
+    // Test case based on Mermaid documentation best practices
+    const diagramWithEntities = `graph TD
+    A["Process "data" file"]
+    B["Node with 'single quotes'"]
+    C{"Check "status" value"}
+    D["Mixed "double" and 'single' quotes"]`;
+    
+    const validation = await validateMermaidDiagram(diagramWithEntities);
+    
+    // HTML entities should be valid according to Mermaid specs
+    expect(validation.isValid).toBe(true);
+    if (!validation.isValid) {
+      console.log('Validation error:', validation.error);
+    }
+  });
+  
+  it('should accept numeric HTML entities', async () => {
+    const diagramWithNumericEntities = `graph TD
+    A["Quote: " and apostrophe: '"]
+    B["Hash: # and ampersand: &"]`;
+    
+    const validation = await validateMermaidDiagram(diagramWithNumericEntities);
+    expect(validation.isValid).toBe(true);
+  });
+  
+  it('should accept mixed HTML entities and regular text', async () => {
+    const diagram = `flowchart LR
+    A["Starting point"]
+    B["Process "important" data"]
+    C["Check if value = "expected""]
+    D["Output: 'success' or 'failure'"]`;
+    
+    const validation = await validateMermaidDiagram(diagram);
+    expect(validation.isValid).toBe(true);
+  });
+  
+  it('should not flag HTML entities as single quotes error', async () => {
+    const diagram = `graph TD
+    A["Text with ' entity"]`;
+    
+    const validation = await validateMermaidDiagram(diagram);
+    
+    // Should not trigger the single quote validation error
+    if (!validation.isValid) {
+      expect(validation.error).not.toContain('Single quotes in node label');
+      expect(validation.error).not.toContain('got PS');
+    }
+  });
+  
+  describe('Real-world examples from Mermaid docs', () => {
+    it('should handle example from Mermaid documentation', async () => {
+      // Example adapted from Mermaid official docs
+      const diagram = `flowchart LR
+    A["A double quote:""]
+    B["A dec char:♥"]
+    C["A hash:#"]`;
+      
+      const validation = await validateMermaidDiagram(diagram);
+      expect(validation.isValid).toBe(true);
+    });
+    
+    it('should handle complex escaping example', async () => {
+      // Complex example from StackOverflow Mermaid discussion
+      const diagram = `flowchart LR
+    B[""<<>>&½#189;""]`;
+      
+      const validation = await validateMermaidDiagram(diagram);
+      expect(validation.isValid).toBe(true);
+    });
+  });
+});

package/data/probe/npm/tests/unit/mermaidInfiniteLoopFix.test.js

@@ -0,0 +1,64 @@
+import { jest, beforeEach, describe, it, expect } from '@jest/globals';
+import { validateMermaidDiagram, validateAndFixMermaidResponse, MermaidFixingAgent } from '../../src/agent/schemaUtils.js';
+
+describe('Mermaid Infinite Loop Fix', () => {
+  describe('Node label quote handling', () => {
+    it('should validate that HTML entities work in Mermaid diagrams', async () => {
+      const diagramWithEntities = `graph TD
+    A["Process "data" file"]
+    B["Handle 'special' case"]
+    C{"Check "status""}`;
+
+      const validation = await validateMermaidDiagram(diagramWithEntities);
+
+      // HTML entities should not trigger single quote validation errors
+      if (!validation.isValid) {
+        expect(validation.error).not.toMatch(/Single quotes in node label/);
+        expect(validation.error).not.toMatch(/got PS/);
+      }
+    });
+  });
+
+  describe('Diamond node quote handling', () => {
+  });
+
+  describe('MermaidFixingAgent should not pass schema to avoid infinite loops', () => {
+    it('should call agent.answer without schema parameter', async () => {
+      // Create a mock ProbeAgent
+      const mockAgent = {
+        answer: jest.fn().mockResolvedValue('```mermaid\ngraph TD\n    A --> B\n```')
+      };
+
+      // Create MermaidFixingAgent and inject mock
+      const fixer = new MermaidFixingAgent({ debug: false });
+      await fixer.initializeAgent();
+      fixer.agent = mockAgent;
+
+      // Call fixMermaidDiagram
+      const brokenDiagram = 'graph TD\n    A["broken (syntax"]';
+      await fixer.fixMermaidDiagram(brokenDiagram, ['line 1: unclosed bracket'], {});
+
+      // Verify that answer was called without schema
+      expect(mockAgent.answer).toHaveBeenCalled();
+      const callArgs = mockAgent.answer.mock.calls[0];
+      expect(callArgs[0]).toContain('Analyze and fix'); // prompt
+      expect(callArgs[1]).toEqual([]); // messages array
+
+      // Critical: verify no schema in options (either no 3rd arg or 3rd arg has no schema)
+      if (callArgs.length >= 3) {
+        expect(callArgs[2]).not.toHaveProperty('schema');
+      }
+    });
+
+    it('should initialize ProbeAgent with maxIterations set to 10', async () => {
+      // Create MermaidFixingAgent
+      const fixer = new MermaidFixingAgent({ debug: false });
+
+      // Initialize the agent
+      const agent = await fixer.initializeAgent();
+
+      // Verify maxIterations is set to 10 (increased from 2 to handle complex diagrams)
+      expect(agent.maxIterations).toBe(10);
+    });
+  });
+});