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

package/data/probe/npm/tests/unit/attempt-completion-closing-tag-in-content.test.js

@@ -0,0 +1,188 @@
+import { parseXmlToolCallWithThinking } from '../../src/agent/tools.js';
+
+/**
+ * Test for fixing issue where JSON content containing "</attempt_completion>" string
+ * causes the XML parser to truncate the content prematurely.
+ *
+ * GitHub Issue: Content with closing tag string gets truncated
+ *
+ * Problem: When attempt_completion contains JSON with a suggestion like:
+ *   "suggestion": "Use regex: /<attempt_completion>/"
+ * The parser finds this "</attempt_completion>" and treats it as the closing tag,
+ * truncating the JSON and causing validation errors.
+ */
+describe('attempt_completion with closing tag in content', () => {
+  test('should handle JSON content with escaped closing tag in string', () => {
+    const xmlString = `<attempt_completion>
+{
+  "issues": [
+    {
+      "file": "npm/src/agent/contextCompactor.js",
+      "line": 115,
+      "ruleId": "logic/weak-pattern-matching",
+      "message": "The attempt_completion detection uses simple string matching",
+      "severity": "warning",
+      "category": "logic",
+      "suggestion": "Use more precise regex pattern to match actual XML tags: /<attempt_completion(?:[^>]*)>/ or /<\\/attempt_completion>/",
+      "replacement": "if (/<attempt_completion(?:[^>]*)>|<\\/attempt_completion>/.test(content)) {"
+    }
+  ]
+}
+</attempt_completion>`;
+
+    const result = parseXmlToolCallWithThinking(xmlString);
+
+    expect(result).toBeDefined();
+    expect(result.toolName).toBe('attempt_completion');
+    expect(result.params.result).toBeDefined();
+
+    // Verify the JSON is complete and parseable
+    const jsonResult = JSON.parse(result.params.result);
+    expect(jsonResult.issues).toHaveLength(1);
+    expect(jsonResult.issues[0].suggestion).toContain('</attempt_completion>');
+    expect(jsonResult.issues[0].replacement).toContain('</attempt_completion>');
+  });
+
+  test('should handle content with closing tag string in plain text', () => {
+    const xmlString = `<attempt_completion>
+The issue is in the XML parser. It searches for </attempt_completion> using indexOf(),
+which finds the first occurrence rather than the actual closing tag. This causes truncation
+when the content contains strings like </attempt_completion> in regex patterns or code examples.
+</attempt_completion>`;
+
+    const result = parseXmlToolCallWithThinking(xmlString);
+
+    expect(result).toBeDefined();
+    expect(result.toolName).toBe('attempt_completion');
+    expect(result.params.result).toContain('</attempt_completion>');
+    expect(result.params.result).toContain('This causes truncation');
+  });
+
+  test('should handle multiple occurrences of closing tag string in content', () => {
+    const xmlString = `<attempt_completion>
+{
+  "patterns": [
+    "Pattern 1: </attempt_completion>",
+    "Pattern 2: <\\/attempt_completion>",
+    "Pattern 3: </attempt_completion>"
+  ],
+  "note": "All patterns above should be preserved"
+}
+</attempt_completion>`;
+
+    const result = parseXmlToolCallWithThinking(xmlString);
+
+    expect(result).toBeDefined();
+    expect(result.toolName).toBe('attempt_completion');
+
+    const jsonResult = JSON.parse(result.params.result);
+    expect(jsonResult.patterns).toHaveLength(3);
+    expect(jsonResult.patterns[0]).toContain('</attempt_completion>');
+    expect(jsonResult.patterns[1]).toContain('</attempt_completion>');
+    expect(jsonResult.patterns[2]).toContain('</attempt_completion>');
+    expect(jsonResult.note).toBe('All patterns above should be preserved');
+  });
+
+  test('should handle closing tag in markdown code block', () => {
+    const xmlString = `<attempt_completion>
+## Fix Instructions
+
+The XML parser needs to be updated:
+
+\`\`\`javascript
+// Before (buggy):
+const closeIndex = xmlString.indexOf('</attempt_completion>');
+
+// After (fixed):
+const closeIndex = xmlString.lastIndexOf('</attempt_completion>');
+\`\`\`
+
+This ensures we find the actual closing tag, not one in the content.
+</attempt_completion>`;
+
+    const result = parseXmlToolCallWithThinking(xmlString);
+
+    expect(result).toBeDefined();
+    expect(result.toolName).toBe('attempt_completion');
+    expect(result.params.result).toContain('## Fix Instructions');
+    expect(result.params.result).toContain('indexOf');
+    expect(result.params.result).toContain('lastIndexOf');
+    expect(result.params.result).toContain('This ensures we find the actual closing tag');
+  });
+
+  test('should handle nested XML-like content', () => {
+    const xmlString = `<attempt_completion>
+<analysis>
+  <finding>The code uses indexOf to find </attempt_completion></finding>
+  <recommendation>Use lastIndexOf or proper XML parsing</recommendation>
+</analysis>
+</attempt_completion>`;
+
+    const result = parseXmlToolCallWithThinking(xmlString);
+
+    expect(result).toBeDefined();
+    expect(result.toolName).toBe('attempt_completion');
+    expect(result.params.result).toContain('<analysis>');
+    expect(result.params.result).toContain('<finding>');
+    expect(result.params.result).toContain('</attempt_completion></finding>');
+    expect(result.params.result).toContain('</recommendation>');
+    expect(result.params.result).toContain('</analysis>');
+  });
+
+  test('should reproduce the exact issue from the log', () => {
+    // This is the exact content from the bug report log
+    const xmlString = `<attempt_completion>
+{
+  "issues": [
+    {
+      "file": "npm/src/agent/contextCompactor.js",
+      "line": 115,
+      "ruleId": "logic/weak-pattern-matching",
+      "message": "The attempt_completion detection uses simple string matching which could match content that mentions attempt_completion but isn't actually a completion tag",
+      "severity": "warning",
+      "category": "logic",
+      "suggestion": "Use more precise regex pattern to match actual XML tags: /<attempt_completion(?:[^>]*)>/ or /<\\/attempt_completion>/",
+      "replacement": "if (/<attempt_completion(?:[^>]*)>|<\\/attempt_completion>/.test(content)) {"
+    },
+    {
+      "file": "npm/src/agent/contextCompactor.js",
+      "line": 88,
+      "ruleId": "logic/weak-pattern-matching",
+      "message": "Tool result detection uses simple string matching which could have false positives",
+      "severity": "warning",
+      "category": "logic",
+      "suggestion": "Use more precise regex pattern to match actual tool_result tags: /<tool_result>/",
+      "replacement": "const isToolResult = /<tool_result>/.test(content);"
+    },
+    {
+      "file": "npm/src/agent/ProbeAgent.js",
+      "line": 2480,
+      "ruleId": "logic/incomplete-error-handling",
+      "message": "Storage error handling only logs but doesn't propagate the error, potentially leaving the system in an inconsistent state",
+      "severity": "warning",
+      "category": "logic",
+      "suggestion": "Either propagate the error or implement a retry mechanism to ensure data consistency",
+      "replacement": "    } catch (error) {\\n      console.error(\`[ERROR] Failed to save compacted messages to storage:\`, error);\\n      throw new Error(\`Failed to save compacted history: \${error.message}\`);\\n    }"
+    }
+  ]
+}
+</attempt_completion>`;
+
+    const result = parseXmlToolCallWithThinking(xmlString);
+
+    expect(result).toBeDefined();
+    expect(result.toolName).toBe('attempt_completion');
+    expect(result.params.result).toBeDefined();
+
+    // The result should be valid JSON
+    let jsonResult;
+    expect(() => {
+      jsonResult = JSON.parse(result.params.result);
+    }).not.toThrow();
+
+    // Verify the complete structure
+    expect(jsonResult.issues).toHaveLength(3);
+    expect(jsonResult.issues[0].replacement).toContain('</attempt_completion>');
+    expect(jsonResult.issues[2].replacement).toContain('Failed to save compacted history');
+  });
+});

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

@@ -0,0 +1,238 @@
+/**
+ * Unit tests for attempt_completion JSON schema fix
+ * Tests the core functionality without requiring full ProbeAgent integration
+ */
+
+import { describe, test, expect } from '@jest/globals';
+import { 
+  cleanSchemaResponse, 
+  validateJsonResponse, 
+  isJsonSchemaDefinition,
+  createJsonCorrectionPrompt,
+  createSchemaDefinitionCorrectionPrompt 
+} from '../../src/agent/schemaUtils.js';
+
+describe('attempt_completion JSON schema fix', () => {
+  
+  describe('Core Schema Processing Logic', () => {
+    test('should detect when AI returns schema definition instead of data', () => {
+      // Simulate attempt_completion result that contains schema definition
+      const schemaDefinitionResponse = `\`\`\`json
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "word-count",
+  "title": "Word Count Result",
+  "description": "Result of word counting operation",
+  "type": "object",
+  "required": ["message", "count"],
+  "properties": {
+    "message": {
+      "type": "string",
+      "description": "A descriptive message about the word count"
+    },
+    "count": {
+      "type": "number",
+      "description": "The actual number of words counted"
+    }
+  }
+}
+\`\`\``;
+
+      // Clean the response (remove markdown)
+      const cleaned = cleanSchemaResponse(schemaDefinitionResponse);
+      
+      // Should be valid JSON
+      const validation = validateJsonResponse(cleaned);
+      expect(validation.isValid).toBe(true);
+      
+      // But should be detected as schema definition, not data
+      const isSchemaDefinition = isJsonSchemaDefinition(cleaned);
+      expect(isSchemaDefinition).toBe(true);
+    });
+
+    test('should not detect actual data as schema definition', () => {
+      // Simulate correct attempt_completion result with actual data
+      const dataResponse = `\`\`\`json
+{
+  "message": "There are 3 words in the text Hello world test",
+  "count": 3
+}
+\`\`\``;
+
+      // Clean the response
+      const cleaned = cleanSchemaResponse(dataResponse);
+      
+      // Should be valid JSON
+      const validation = validateJsonResponse(cleaned);
+      expect(validation.isValid).toBe(true);
+      
+      // Should NOT be detected as schema definition
+      const isSchemaDefinition = isJsonSchemaDefinition(cleaned);
+      expect(isSchemaDefinition).toBe(false);
+      
+      // Parse and verify it's actual data
+      const parsed = JSON.parse(cleaned);
+      expect(parsed).toHaveProperty('message');
+      expect(parsed).toHaveProperty('count');
+      expect(typeof parsed.message).toBe('string');
+      expect(typeof parsed.count).toBe('number');
+    });
+
+    test('should create appropriate correction prompt for schema definition confusion', () => {
+      const schemaDefinition = JSON.stringify({
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "type": "object",
+        "properties": {
+          "message": {"type": "string"},
+          "count": {"type": "number"}
+        },
+        "required": ["message", "count"]
+      });
+
+      const originalSchema = `{
+  "type": "object",
+  "properties": {
+    "message": {"type": "string"},
+    "count": {"type": "number"}
+  },
+  "required": ["message", "count"]
+}`;
+
+      // Test first correction attempt
+      const correctionPrompt = createSchemaDefinitionCorrectionPrompt(
+        schemaDefinition, 
+        originalSchema, 
+        0
+      );
+
+      expect(correctionPrompt).toContain('CRITICAL MISUNDERSTANDING:');
+      expect(correctionPrompt).toContain('You returned a JSON schema definition instead of data');
+      expect(correctionPrompt).toContain('You must return ACTUAL DATA');
+      expect(correctionPrompt).toContain('Instead of: {"type": "object"');
+      expect(correctionPrompt).toContain('Return: {"actualData": "value"');
+      expect(correctionPrompt).toContain(originalSchema);
+    });
+
+    test('should create escalating correction prompts for invalid JSON', () => {
+      const invalidResponse = 'Based on the text "Hello world test", I can count that there are 3 words.';
+      const schema = `{"type": "object", "properties": {"message": {"type": "string"}, "count": {"type": "number"}}}`;
+      const error = 'Unexpected token B in JSON at position 0';
+
+      // Test escalating prompts
+      const prompts = [
+        createJsonCorrectionPrompt(invalidResponse, schema, error, 0),
+        createJsonCorrectionPrompt(invalidResponse, schema, error, 1),
+        createJsonCorrectionPrompt(invalidResponse, schema, error, 2)
+      ];
+
+      expect(prompts[0]).toContain('CRITICAL JSON ERROR:');
+      expect(prompts[1]).toContain('URGENT - JSON PARSING FAILED:');
+      expect(prompts[2]).toContain('FINAL ATTEMPT - CRITICAL JSON ERROR:');
+
+      // All should contain the error and schema
+      prompts.forEach(prompt => {
+        expect(prompt).toContain(error);
+        expect(prompt).toContain(schema);
+        expect(prompt).toContain(invalidResponse.substring(0, 100));
+      });
+    });
+
+    test('should properly clean markdown from attempt_completion responses', () => {
+      const testCases = [
+        {
+          input: 'Based on analysis:\n\n```json\n{"result": "success"}\n```\n\nThis completes the task.',
+          expected: '{"result": "success"}',
+          description: 'should extract JSON from markdown with surrounding text'
+        },
+        {
+          input: '```json\n{"message": "Word count is 3", "count": 3}\n```',
+          expected: '{"message": "Word count is 3", "count": 3}',
+          description: 'should extract clean JSON from simple markdown block'
+        },
+        {
+          input: 'Plain text response without JSON',
+          expected: 'Plain text response without JSON',
+          description: 'should return plain text unchanged when no JSON found'
+        },
+        {
+          input: '{"direct": "json", "without": "markdown"}',
+          expected: '{"direct": "json", "without": "markdown"}',
+          description: 'should handle direct JSON without markdown'
+        }
+      ];
+
+      testCases.forEach(({ input, expected, description }) => {
+        const result = cleanSchemaResponse(input);
+        expect(result).toBe(expected);
+      });
+    });
+  });
+
+  describe('JSON Validation Edge Cases', () => {
+    test('should handle malformed JSON responses', () => {
+      const malformedResponses = [
+        '{"incomplete": ',
+        '{"missing": "quote}',
+        '{"trailing": "comma",}',
+        '{invalid: "property"}'
+      ];
+
+      malformedResponses.forEach(response => {
+        const validation = validateJsonResponse(response);
+        expect(validation.isValid).toBe(false);
+        expect(validation.error).toBeDefined();
+      });
+    });
+
+    test('should validate correct JSON responses', () => {
+      const validResponses = [
+        '{"simple": "object"}',
+        '["array", "of", "strings"]',
+        '{"nested": {"object": {"with": "values"}}}',
+        '{"mixed": ["array", 123, {"nested": true}]}'
+      ];
+
+      validResponses.forEach(response => {
+        const validation = validateJsonResponse(response);
+        expect(validation.isValid).toBe(true);
+        expect(validation.parsed).toBeDefined();
+      });
+    });
+  });
+
+  describe('Integration Simulation', () => {
+    test('should simulate the complete attempt_completion JSON correction flow', () => {
+      // Step 1: Simulate attempt_completion returning markdown
+      const attemptCompletionResult = 'Based on my analysis of the text "Hello world test", I can confirm there are 3 words total.';
+
+      // Step 2: Clean any potential markdown
+      const cleaned = cleanSchemaResponse(attemptCompletionResult);
+      expect(cleaned).toBe(attemptCompletionResult); // No markdown to clean
+
+      // Step 3: Validate as JSON
+      const validation = validateJsonResponse(cleaned);
+      expect(validation.isValid).toBe(false); // Plain text is not JSON
+
+      // Step 4: Create correction prompt
+      const schema = '{"type": "object", "properties": {"message": {"type": "string"}, "count": {"type": "number"}}}';
+      const correctionPrompt = createJsonCorrectionPrompt(
+        cleaned, 
+        schema, 
+        validation.error, 
+        0
+      );
+
+      expect(correctionPrompt).toContain('CRITICAL JSON ERROR:');
+      expect(correctionPrompt).toContain('You MUST fix this and return ONLY valid JSON');
+      expect(correctionPrompt).toContain(schema);
+      expect(correctionPrompt).toContain(attemptCompletionResult.substring(0, 100));
+
+      // Step 5: Simulate corrected response
+      const correctedResponse = '{"message": "There are 3 words in the text Hello world test", "count": 3}';
+      const finalValidation = validateJsonResponse(correctedResponse);
+      expect(finalValidation.isValid).toBe(true);
+      expect(finalValidation.parsed.message).toContain('3 words');
+      expect(finalValidation.parsed.count).toBe(3);
+    });
+  });
+});

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

@@ -0,0 +1,128 @@
+import { describe, test, expect } from '@jest/globals';
+import { cleanSchemaResponse, isJsonSchemaDefinition } from '../../src/agent/schemaUtils.js';
+
+describe('attempt_completion JSON parsing issue', () => {
+  test('should reproduce the issue where attempt_completion result with markdown causes JSON parsing errors', () => {
+    // This is the actual result format from the failure log
+    const attemptCompletionResult = `\`\`\`json
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "code-review",
+  "title": "Code Review",
+  "description": "Structured format for code review issues",
+  "type": "object",
+  "required": [
+    "issues"
+  ],
+  "properties": {
+    "issues": {
+      "type": "array",
+      "description": "List of issues found during code review",
+      "items": [
+        {
+          "file": "docs/failure-conditions-implementation.md",
+          "line": 1,
+          "ruleId": "documentation/inconsistency",
+          "message": "The documentation and examples consistently refer to JEXL as the expression language, but the implementation uses sandboxed JavaScript. This is highly misleading for users trying to write conditions.",
+          "severity": "error",
+          "category": "documentation",
+          "suggestion": "Update all documentation, including markdown files and YAML examples, to correctly refer to JavaScript expressions. Remove all mentions of JEXL to avoid confusion and ensure users are writing valid conditions based on the actual implementation."
+        }
+      ]
+    }
+  }
+}
+\`\`\``;
+
+    // Test that this fails when parsed directly as JSON
+    expect(() => JSON.parse(attemptCompletionResult)).toThrow();
+
+    // Test that cleanSchemaResponse would handle this correctly
+    const cleaned = cleanSchemaResponse(attemptCompletionResult);
+    
+    // After cleaning, it should be valid JSON
+    expect(() => JSON.parse(cleaned)).not.toThrow();
+    
+    const parsed = JSON.parse(cleaned);
+    expect(parsed).toHaveProperty('$schema');
+    expect(parsed).toHaveProperty('properties');
+    expect(parsed.properties).toHaveProperty('issues');
+
+    // NEW: Verify this is detected as a schema definition (the bug!)
+    expect(isJsonSchemaDefinition(cleaned)).toBe(true);
+  });
+
+  test('should detect when AI returns schema definition instead of data', () => {
+    // This is the problematic response - AI returned schema definition instead of data
+    const problemResponse = `\`\`\`json
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "code-review",
+  "title": "Code Review", 
+  "description": "Structured format for code review issues",
+  "type": "object",
+  "required": ["issues"],
+  "properties": {
+    "issues": {
+      "type": "array",
+      "description": "List of issues found during code review",
+      "items": {
+        "type": "object",
+        "properties": {
+          "file": { "type": "string" },
+          "line": { "type": "number" },
+          "message": { "type": "string" },
+          "severity": { "type": "string" }
+        }
+      }
+    }
+  }
+}
+\`\`\``;
+
+    const cleaned = cleanSchemaResponse(problemResponse);
+    expect(isJsonSchemaDefinition(cleaned)).toBe(true);
+
+    // This is what should have been returned instead (actual data)
+    const correctResponse = JSON.stringify({
+      "issues": [
+        {
+          "file": "docs/failure-conditions-implementation.md",
+          "line": 1,
+          "message": "Documentation inconsistency found",
+          "severity": "error"
+        }
+      ]
+    });
+
+    expect(isJsonSchemaDefinition(correctResponse)).toBe(false);
+  });
+
+  test('should handle attempt_completion result that is plain text', () => {
+    const plainTextResult = "Hello! I've reviewed the pull request and focused on performance aspects as requested. The introduction of conditional execution is a powerful feature.";
+
+    const cleaned = cleanSchemaResponse(plainTextResult);
+    
+    // Plain text should remain unchanged
+    expect(cleaned).toBe(plainTextResult);
+  });
+
+  test('should handle attempt_completion result with mixed content', () => {
+    const mixedResult = `Here is my analysis:
+
+\`\`\`json
+{
+  "summary": "The code looks good",
+  "issues": []
+}
+\`\`\`
+
+Additional notes: The implementation is solid.`;
+
+    const cleaned = cleanSchemaResponse(mixedResult);
+    
+    // Should extract just the JSON part
+    expect(cleaned.trim()).toBe('{\n  "summary": "The code looks good",\n  "issues": []\n}');
+    expect(() => JSON.parse(cleaned)).not.toThrow();
+  });
+});

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

@@ -0,0 +1,35 @@
+import { validateAndFixMermaidResponse } from '../../src/agent/schemaUtils.js';
+
+describe('Mermaid Auto-Fix - Backticks', () => {
+  const mockOptions = {
+    debug: false,
+    path: '/test/path',
+    provider: 'anthropic',
+    model: 'claude-3-sonnet-20240229'
+  };
+
+  describe('Auto-fix backticks in node labels', () => {
+
+
+
+
+
+    test('should remove backticks from quoted labels', async () => {
+      const response = `\`\`\`mermaid
+flowchart TD
+    A["Already quoted \`backticks\`"] --> B{"Also quoted \`here\`"}
+\`\`\``;
+
+      const result = await validateAndFixMermaidResponse(response, mockOptions);
+
+      // @probelabs/maid v0.0.15+ treats backticks inside quoted labels as errors (FL-LABEL-BACKTICK)
+      // and removes them during auto-fix. This is the expected behavior.
+      expect(result.fixedResponse).toContain('A["Already quoted backticks"]');
+      expect(result.fixedResponse).toContain('B{"Also quoted here"}');
+    });
+
+  });
+
+  describe('Validation detects backticks correctly', () => {
+  });
+});