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

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

@@ -0,0 +1,345 @@
+import { jest, describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+
+// Mock all the heavy dependencies that ProbeAgent uses
+jest.mock('@ai-sdk/anthropic', () => ({}));
+jest.mock('@ai-sdk/openai', () => ({}));
+jest.mock('@ai-sdk/google', () => ({}));
+jest.mock('@ai-sdk/amazon-bedrock', () => ({}));
+jest.mock('ai', () => ({
+  generateText: jest.fn(),
+  streamText: jest.fn(),
+  tool: jest.fn((config) => ({
+    name: config.name,
+    description: config.description,
+    inputSchema: config.inputSchema,
+    execute: config.execute
+  }))
+}));
+
+import { ProbeAgent } from '../../src/agent/ProbeAgent.js';
+import { writeFileSync, unlinkSync, existsSync, mkdirSync, rmSync } from 'fs';
+import { join } from 'path';
+
+describe('Image Path Resolution', () => {
+  let testDir;
+  let agent;
+  let testImages;
+
+  beforeEach(() => {
+    // Create a test directory structure
+    testDir = join(process.cwd(), 'test-images-temp');
+    if (!existsSync(testDir)) {
+      mkdirSync(testDir, { recursive: true });
+    }
+
+    // Create test image files
+    const simplePng = Buffer.from([
+      0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A,
+      0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52,
+      0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
+      0x08, 0x06, 0x00, 0x00, 0x00, 0x1F, 0x15, 0xC4,
+      0x89, 0x00, 0x00, 0x00, 0x0D, 0x49, 0x44, 0x41,
+      0x54, 0x78, 0x9C, 0x62, 0x00, 0x02, 0x00, 0x00,
+      0x05, 0x00, 0x01, 0x0D, 0x0A, 0x2D, 0xB4, 0x00,
+      0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE,
+      0x42, 0x60, 0x82
+    ]);
+
+    testImages = [
+      'policy-1.png',
+      'policy-2.png',
+      'client.png'
+    ];
+
+    testImages.forEach(filename => {
+      writeFileSync(join(testDir, filename), simplePng);
+    });
+
+    // Initialize agent with the test directory
+    agent = new ProbeAgent({
+      debug: false,
+      path: testDir
+    });
+  });
+
+  afterEach(() => {
+    // Cleanup
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('extractListFilesDirectories', () => {
+    test('should extract directory from extract tool File: header', () => {
+      const content = `File: ${testDir}/ticket.md
+Lines: 41-48
+\`\`\`markdown
+  <attachments>
+    <attachment filename="policy-1.png" />
+  </attachments>
+\`\`\``;
+
+      const directories = agent.extractListFilesDirectories(content);
+      expect(directories).toEqual([testDir]);
+    });
+
+    test('should extract directory paths from listFiles output', () => {
+      const content = `${testDir}:
+file    1.2K  policy-1.png
+file    1.1K  policy-2.png
+file    1.3K  client.png`;
+
+      const directories = agent.extractListFilesDirectories(content);
+      expect(directories).toEqual([testDir]);
+    });
+
+    test('should not extract non-directory lines ending with colon', () => {
+      const content = `Token Usage:
+Some random text
+
+${testDir}:
+file    1.2K  policy-1.png`;
+
+      const directories = agent.extractListFilesDirectories(content);
+      expect(directories).toEqual([testDir]);
+      expect(directories).not.toContain('Token Usage');
+    });
+
+    test('should handle relative paths', () => {
+      const content = `./attachments:
+file    1.2K  policy-1.png`;
+
+      const directories = agent.extractListFilesDirectories(content);
+      expect(directories).toEqual(['./attachments']);
+    });
+
+    test('should handle multiple directory sections', () => {
+      const content = `${testDir}:
+file    1.2K  policy-1.png
+
+${testDir}/subdirectory:
+file    1.1K  policy-2.png`;
+
+      const directories = agent.extractListFilesDirectories(content);
+      expect(directories).toHaveLength(2);
+      expect(directories).toContain(testDir);
+      expect(directories).toContain(`${testDir}/subdirectory`);
+    });
+
+    test('should not match headings or other text with colons', () => {
+      const content = `My Dashboard has this log:
+My Gateway has this log:
+Files to extract:
+
+${testDir}:
+file    1.2K  policy-1.png`;
+
+      const directories = agent.extractListFilesDirectories(content);
+      expect(directories).toEqual([testDir]);
+    });
+
+    test('should reject paths with spaces (like "./Token Usage:")', () => {
+      const content = `./Token Usage:
+./Some Text Here:
+This behavior is due to a known bug (TT-8839):
+
+${testDir}:
+file    1.2K  policy-1.png`;
+
+      const directories = agent.extractListFilesDirectories(content);
+      expect(directories).toEqual([testDir]);
+      expect(directories).not.toContain('./Token Usage');
+      expect(directories).not.toContain('./Some Text Here');
+    });
+
+    test('should extract from both File: header and listFiles output without duplicates', () => {
+      const content = `File: ${testDir}/ticket.md
+Lines: 1-10
+Some content
+
+${testDir}:
+file    1.2K  policy-1.png`;
+
+      const directories = agent.extractListFilesDirectories(content);
+      expect(directories).toEqual([testDir]); // Should only have one entry, no duplicates
+    });
+
+    test('should handle extract tool output with relative paths', () => {
+      const content = `File: ./docs/ticket.md
+Lines: 1-10
+Some content`;
+
+      const directories = agent.extractListFilesDirectories(content);
+      expect(directories).toEqual(['./docs']);
+    });
+  });
+
+  describe('processImageReferences with XML attachments', () => {
+    test('should resolve relative image paths from XML attachments using directory context', async () => {
+      // Simulate content with XML attachments and listFiles output
+      const content = `${testDir}:
+file    458K  attachment_2_policy-1.png
+file    436K  attachment_3_policy-2.png
+file    447K  attachment_4_client.png
+
+<attachments>
+  <attachment filename="policy-1.png" size="458477" content_type="image/png" />
+  <attachment filename="policy-2.png" size="436301" content_type="image/png" />
+  <attachment filename="client.png" size="447699" content_type="image/png" />
+</attachments>`;
+
+      await agent.processImageReferences(content);
+
+      // Check that images were loaded
+      const loadedImages = agent.getCurrentImages();
+      expect(loadedImages.length).toBeGreaterThan(0);
+
+      // Verify at least one image was successfully resolved
+      expect(loadedImages.some(img => img.startsWith('data:image/png;base64,'))).toBe(true);
+    });
+
+    test('should handle images when directory context is available from listFiles', async () => {
+      // First, process content with directory context
+      const contentWithDirectory = `${testDir}:
+file    1.2K  policy-1.png
+file    1.1K  policy-2.png`;
+
+      // Then process content with just filename mentions
+      await agent.processImageReferences(contentWithDirectory);
+
+      const contentWithFilenames = 'Look at policy-1.png and policy-2.png for details.';
+      await agent.processImageReferences(contentWithFilenames);
+
+      const loadedImages = agent.getCurrentImages();
+      expect(loadedImages.length).toBeGreaterThan(0);
+    });
+
+    test('should not load images when only non-directory headings are present', async () => {
+      agent.clearLoadedImages();
+
+      const content = `Token Usage:
+Some metrics here
+
+Files to extract:
+- policy-1.png
+- policy-2.png`;
+
+      await agent.processImageReferences(content);
+
+      // Images should not be loaded because no actual directory path was extracted
+      const loadedImages = agent.getCurrentImages();
+      // Images may or may not be loaded depending on if they exist in allowed folders
+      // The key is that "Token Usage" should not be used as a directory
+      expect(agent.extractListFilesDirectories(content)).not.toContain('Token Usage');
+      expect(agent.extractListFilesDirectories(content)).not.toContain('Files to extract');
+    });
+  });
+
+  describe('loadImageIfValid', () => {
+    test('should load image from full path', async () => {
+      const imagePath = join(testDir, 'policy-1.png');
+      const result = await agent.loadImageIfValid(imagePath);
+
+      expect(result).toBe(true);
+      expect(agent.pendingImages.has(imagePath)).toBe(true);
+    });
+
+    test('should load image from relative path when context is available', async () => {
+      // First extract directory context
+      const listFilesOutput = `${testDir}:
+file    1.2K  policy-1.png`;
+
+      await agent.processImageReferences(listFilesOutput);
+
+      // Now try to load with just filename
+      const result = await agent.loadImageIfValid(join(testDir, 'policy-1.png'));
+
+      expect(result).toBe(true);
+    });
+
+    test('should not load non-existent images', async () => {
+      const imagePath = join(testDir, 'nonexistent.png');
+      const result = await agent.loadImageIfValid(imagePath);
+
+      expect(result).toBe(false);
+      expect(agent.pendingImages.has(imagePath)).toBe(false);
+    });
+
+    test('should prevent loading images outside allowed directories', async () => {
+      const outsidePath = '/tmp/outside.png';
+      const result = await agent.loadImageIfValid(outsidePath);
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('Real-world XML attachment scenario', () => {
+    test('should load images from extract tool File: header without needing listFiles', async () => {
+      // This is the CORRECT way - extract tool provides the file path directly
+      const extractToolOutput = `File: ${testDir}/ticket.md
+Lines: 41-48
+\`\`\`markdown
+  <attachments>
+    <attachment filename="policy-1.png" size="458477" content_type="image/png" />
+    <attachment filename="policy-2.png" size="436301" content_type="image/png" />
+    <attachment filename="client.png" size="447699" content_type="image/png" />
+  </attachments>
+\`\`\``;
+
+      // Process the extract tool output
+      await agent.processImageReferences(extractToolOutput);
+
+      // Verify images were loaded
+      const loadedImages = agent.getCurrentImages();
+      expect(loadedImages.length).toBeGreaterThan(0);
+
+      // Verify the images are valid base64 data URLs
+      loadedImages.forEach(img => {
+        expect(img).toMatch(/^data:image\/(png|jpeg|jpg);base64,/);
+      });
+    });
+
+    test('should handle the Zendesk ticket attachment format', async () => {
+      // Simulate the actual scenario from the bug report
+      const ticketContent = `<message id="11842728115356" author="User 8718562264860" created="2023-12-20T03:24:29Z" public="true">
+Hi team,
+
+When we perform the step 'Request an authorization code' of 'Authorization Code Grant Type', if our listen path is /oauth2_code_test, there is no problem, but if the listen path is /oauth2_code_test/a, it will return a 404 error.
+
+Attached is our api json, client and policy configurations and dashboard logs.
+
+Regards,
+
+Salman
+
+  <attachments>
+    <attachment filename="oauth2_code_test.json" size="13243" content_type="application/json" />
+    <attachment filename="policy-1.png" size="458477" content_type="image/png" />
+    <attachment filename="policy-2.png" size="436301" content_type="image/png" />
+    <attachment filename="client.png" size="447699" content_type="image/png" />
+    <attachment filename="dashboard-log.csv.gz" size="6796" content_type="application/x-gzip" />
+  </attachments>
+</message>`;
+
+      // Simulate listFiles being called on the directory
+      // In this test, files are named exactly as in the XML (no prefix)
+      const listFilesOutput = `${testDir}:
+file    1.2K  policy-1.png
+file    1.1K  policy-2.png
+file    1.3K  client.png`;
+
+      // Process both outputs
+      await agent.processImageReferences(listFilesOutput);
+      await agent.processImageReferences(ticketContent);
+
+      // Verify images were loaded
+      const loadedImages = agent.getCurrentImages();
+      expect(loadedImages.length).toBeGreaterThan(0);
+
+      // Verify the images are valid base64 data URLs
+      loadedImages.forEach(img => {
+        expect(img).toMatch(/^data:image\/(png|jpeg|jpg);base64,/);
+      });
+    });
+  });
+});

package/data/probe/npm/tests/unit/json-fixing-agent.test.js

@@ -0,0 +1,238 @@
+/**
+ * Test JsonFixingAgent with separate session isolation
+ */
+
+import { describe, test, expect } from '@jest/globals';
+import { JsonFixingAgent, validateJsonResponse, cleanSchemaResponse } from '../../src/agent/schemaUtils.js';
+
+describe('JsonFixingAgent', () => {
+  describe('constructor', () => {
+    test('should create JsonFixingAgent with default options', () => {
+      const agent = new JsonFixingAgent();
+
+      expect(agent.options.sessionId).toMatch(/^json-fixer-\d+-\d+$/);
+      expect(agent.options.allowEdit).toBe(false);
+      expect(agent.ProbeAgent).toBeNull();
+      expect(agent.agent).toBeUndefined();
+    });
+
+    test('should create JsonFixingAgent with custom options', () => {
+      const options = {
+        sessionId: 'custom-session-123',
+        path: '/custom/path',
+        provider: 'anthropic',
+        model: 'claude-3-5-sonnet-20241022',
+        debug: true
+      };
+
+      const agent = new JsonFixingAgent(options);
+
+      expect(agent.options.sessionId).toBe('custom-session-123');
+      expect(agent.options.path).toBe('/custom/path');
+      expect(agent.options.provider).toBe('anthropic');
+      expect(agent.options.model).toBe('claude-3-5-sonnet-20241022');
+      expect(agent.options.debug).toBe(true);
+      expect(agent.options.allowEdit).toBe(false); // Always false for safety
+    });
+  });
+
+  describe('getJsonFixingPrompt', () => {
+    test('should return specialized JSON fixing prompt', () => {
+      const agent = new JsonFixingAgent();
+      const prompt = agent.getJsonFixingPrompt();
+
+      // Check for key elements of the prompt
+      expect(prompt).toContain('JSON syntax correction specialist');
+      expect(prompt).toContain('CORE RESPONSIBILITIES');
+      expect(prompt).toContain('JSON SYNTAX RULES');
+      expect(prompt).toContain('COMMON ERRORS TO FIX');
+      expect(prompt).toContain('FIXING METHODOLOGY');
+      expect(prompt).toContain('CRITICAL RULES');
+
+      // Check for specific syntax rules
+      expect(prompt).toContain('Property names');
+      expect(prompt).toContain('double quotes');
+      expect(prompt).toContain('No trailing commas');
+
+      // Check for common errors
+      expect(prompt).toContain('Unquoted property names');
+      expect(prompt).toContain('Single quotes');
+      expect(prompt).toContain('Trailing commas');
+
+      // Check for critical rules
+      expect(prompt).toContain('NEVER add explanations');
+      expect(prompt).toContain('NEVER wrap in markdown');
+      expect(prompt).toContain('PRESERVE the original data structure');
+    });
+  });
+
+  describe('initializeAgent', () => {
+    test('should initialize ProbeAgent lazily', async () => {
+      const agent = new JsonFixingAgent({
+        sessionId: 'test-session',
+        debug: false
+      });
+
+      expect(agent.ProbeAgent).toBeNull();
+      expect(agent.agent).toBeUndefined();
+
+      // Initialize the agent
+      await agent.initializeAgent();
+
+      // Check that ProbeAgent was imported and agent was created
+      expect(agent.ProbeAgent).not.toBeNull();
+      expect(agent.agent).toBeDefined();
+      expect(agent.agent.sessionId).toBe('test-session');
+      expect(agent.agent.disableJsonValidation).toBe(true); // CRITICAL for preventing recursion
+    });
+
+    test('should not reinitialize agent if already initialized', async () => {
+      const agent = new JsonFixingAgent();
+
+      await agent.initializeAgent();
+      const firstAgent = agent.agent;
+
+      await agent.initializeAgent();
+      const secondAgent = agent.agent;
+
+      // Should be the same instance
+      expect(secondAgent).toBe(firstAgent);
+    });
+
+    test('should create agent with disableJsonValidation=true', async () => {
+      const agent = new JsonFixingAgent({
+        debug: false
+      });
+
+      await agent.initializeAgent();
+
+      // This is CRITICAL to prevent infinite recursion
+      expect(agent.agent.disableJsonValidation).toBe(true);
+    });
+
+    test('should create agent with allowEdit=false', async () => {
+      const agent = new JsonFixingAgent();
+
+      await agent.initializeAgent();
+
+      // Agent should not be able to edit files (only fix JSON syntax)
+      expect(agent.agent.allowEdit).toBe(false);
+    });
+
+    test('should create agent with maxIterations=5', async () => {
+      const agent = new JsonFixingAgent();
+
+      await agent.initializeAgent();
+
+      expect(agent.agent.maxIterations).toBe(5);
+    });
+  });
+
+  describe('session isolation', () => {
+    test('should use unique session ID per instance', async () => {
+      const agent1 = new JsonFixingAgent();
+      // Small delay to ensure different timestamp
+      await new Promise(resolve => setTimeout(resolve, 1));
+      const agent2 = new JsonFixingAgent();
+
+      expect(agent1.options.sessionId).not.toBe(agent2.options.sessionId);
+    });
+
+    test('should create separate session from parent agent', async () => {
+      const agent = new JsonFixingAgent({
+        sessionId: 'json-fixer-test-123'
+      });
+
+      await agent.initializeAgent();
+
+      // Session ID should be the custom one
+      expect(agent.agent.sessionId).toBe('json-fixer-test-123');
+
+      // Agent should be completely isolated (no shared history with parent)
+      expect(agent.agent.history).toEqual([]);
+    });
+  });
+
+  describe('cancel and cleanup', () => {
+    test('should have cancel method', () => {
+      const agent = new JsonFixingAgent();
+
+      expect(typeof agent.cancel).toBe('function');
+
+      // Should not throw when agent not initialized
+      expect(() => agent.cancel()).not.toThrow();
+    });
+
+    test('should cancel initialized agent', async () => {
+      const agent = new JsonFixingAgent();
+      await agent.initializeAgent();
+
+      expect(() => agent.cancel()).not.toThrow();
+    });
+
+    test('should have getTokenUsage method', () => {
+      const agent = new JsonFixingAgent();
+
+      expect(typeof agent.getTokenUsage).toBe('function');
+      expect(agent.getTokenUsage()).toBeNull(); // No agent initialized
+    });
+  });
+
+  describe('integration with validation flow', () => {
+    test('should follow clean-then-validate workflow', () => {
+      // Step 1: AI returns JSON with markdown
+      const aiResponse = '```json\n{"name": "test", "id": 42}\n```';
+
+      // Step 2: Clean the response
+      const cleaned = cleanSchemaResponse(aiResponse);
+      expect(cleaned).toBe('{"name": "test", "id": 42}');
+
+      // Step 3: Validate
+      const validation = validateJsonResponse(cleaned);
+      expect(validation.isValid).toBe(true);
+
+      // If invalid, JsonFixingAgent would be used (tested separately with mocks)
+    });
+
+    test('should provide enhanced error for fixing', () => {
+      const invalidJson = '{"name": "test", "value": invalid}';
+
+      const validation = validateJsonResponse(invalidJson);
+
+      expect(validation.isValid).toBe(false);
+      expect(validation.enhancedError).toBeDefined();
+      expect(validation.errorContext).toBeDefined();
+
+      // JsonFixingAgent.fixJson() would receive this enhanced error
+      expect(validation.enhancedError).toContain('Error location');
+      expect(validation.enhancedError).toContain('^ here');
+    });
+  });
+
+  describe('architectural consistency with MermaidFixingAgent', () => {
+    test('should follow same pattern as MermaidFixingAgent', async () => {
+      const jsonAgent = new JsonFixingAgent({ sessionId: 'json-test' });
+      await jsonAgent.initializeAgent();
+
+      // Both should have:
+      // 1. Separate session
+      expect(jsonAgent.agent.sessionId).toBe('json-test');
+
+      // 2. allowEdit=false
+      expect(jsonAgent.agent.allowEdit).toBe(false);
+
+      // 3. Specialized prompt
+      expect(jsonAgent.agent.customPrompt).toBeDefined();
+      expect(jsonAgent.agent.customPrompt).toContain('specialist');
+
+      // 4. Recursion prevention flag
+      expect(jsonAgent.agent.disableJsonValidation).toBe(true); // JSON equivalent of disableMermaidValidation
+
+      // 5. Cancel method
+      expect(typeof jsonAgent.cancel).toBe('function');
+
+      // 6. Token usage method
+      expect(typeof jsonAgent.getTokenUsage).toBe('function');
+    });
+  });
+});