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

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

@@ -0,0 +1,282 @@
+/**
+ * Unit tests for SimpleTelemetry and SimpleAppTracer
+ * @module tests/unit/simpleTelemetry
+ */
+
+import { jest, describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+import { SimpleTelemetry, SimpleAppTracer } from '../../src/agent/simpleTelemetry.js';
+
+describe('SimpleTelemetry', () => {
+  let telemetry;
+
+  beforeEach(() => {
+    telemetry = new SimpleTelemetry({
+      serviceName: 'test-service',
+      enableConsole: false,
+      enableFile: false
+    });
+  });
+
+  afterEach(async () => {
+    await telemetry.shutdown();
+  });
+
+  describe('createSpan', () => {
+    test('should create a span with name and attributes', () => {
+      const span = telemetry.createSpan('test-span', { 'test.attr': 'value' });
+
+      expect(span.name).toBe('test-span');
+      expect(span.attributes).toMatchObject({
+        'test.attr': 'value',
+        service: 'test-service'
+      });
+      expect(span.traceId).toBeDefined();
+      expect(span.spanId).toBeDefined();
+    });
+
+    test('should allow adding events to spans', () => {
+      const span = telemetry.createSpan('test-span');
+
+      span.addEvent('test-event', { 'event.data': 'test' });
+
+      expect(span.events).toHaveLength(1);
+      expect(span.events[0].name).toBe('test-event');
+      expect(span.events[0].attributes).toMatchObject({ 'event.data': 'test' });
+    });
+
+    test('should allow setting attributes', () => {
+      const span = telemetry.createSpan('test-span');
+
+      span.setAttributes({ 'new.attr': 'new-value' });
+
+      expect(span.attributes['new.attr']).toBe('new-value');
+    });
+
+    test('should allow setting status', () => {
+      const span = telemetry.createSpan('test-span');
+
+      // setStatus modifies the internal span state used during export
+      // The function should not throw and should be callable
+      expect(() => span.setStatus('ERROR')).not.toThrow();
+    });
+  });
+});
+
+describe('SimpleAppTracer', () => {
+  let telemetry;
+  let tracer;
+
+  beforeEach(() => {
+    telemetry = new SimpleTelemetry({
+      serviceName: 'test-service',
+      enableConsole: false,
+      enableFile: false
+    });
+    tracer = new SimpleAppTracer(telemetry, 'test-session-123');
+  });
+
+  afterEach(async () => {
+    await tracer.shutdown();
+  });
+
+  describe('constructor', () => {
+    test('should initialize with provided session ID', () => {
+      expect(tracer.sessionId).toBe('test-session-123');
+    });
+
+    test('should generate session ID if not provided', () => {
+      const tracerWithoutSession = new SimpleAppTracer(telemetry);
+      expect(tracerWithoutSession.sessionId).toBeDefined();
+      expect(tracerWithoutSession.sessionId.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('isEnabled', () => {
+    test('should return true when telemetry is provided', () => {
+      expect(tracer.isEnabled()).toBe(true);
+    });
+
+    test('should return false when telemetry is null', () => {
+      const disabledTracer = new SimpleAppTracer(null, 'session-123');
+      expect(disabledTracer.isEnabled()).toBe(false);
+    });
+  });
+
+  describe('recordEvent', () => {
+    test('should record event with name and attributes', () => {
+      // Mock addEvent
+      const addEventSpy = jest.spyOn(tracer, 'addEvent');
+
+      tracer.recordEvent('test.event', { 'custom.attr': 'value' });
+
+      expect(addEventSpy).toHaveBeenCalledWith('test.event', {
+        'session.id': 'test-session-123',
+        'custom.attr': 'value'
+      });
+    });
+
+    test('should not record event when tracer is disabled', () => {
+      const disabledTracer = new SimpleAppTracer(null, 'session-123');
+      const addEventSpy = jest.spyOn(disabledTracer, 'addEvent');
+
+      disabledTracer.recordEvent('test.event', { 'custom.attr': 'value' });
+
+      expect(addEventSpy).not.toHaveBeenCalled();
+    });
+
+    test('should support completion_prompt.started event', () => {
+      const addEventSpy = jest.spyOn(tracer, 'addEvent');
+
+      tracer.recordEvent('completion_prompt.started', {
+        'completion_prompt.original_result_length': 100
+      });
+
+      expect(addEventSpy).toHaveBeenCalledWith('completion_prompt.started', {
+        'session.id': 'test-session-123',
+        'completion_prompt.original_result_length': 100
+      });
+    });
+
+    test('should support completion_prompt.completed event', () => {
+      const addEventSpy = jest.spyOn(tracer, 'addEvent');
+
+      tracer.recordEvent('completion_prompt.completed', {
+        'completion_prompt.final_result_length': 200
+      });
+
+      expect(addEventSpy).toHaveBeenCalledWith('completion_prompt.completed', {
+        'session.id': 'test-session-123',
+        'completion_prompt.final_result_length': 200
+      });
+    });
+
+    test('should support completion_prompt.error event', () => {
+      const addEventSpy = jest.spyOn(tracer, 'addEvent');
+
+      tracer.recordEvent('completion_prompt.error', {
+        'completion_prompt.error': 'Test error message'
+      });
+
+      expect(addEventSpy).toHaveBeenCalledWith('completion_prompt.error', {
+        'session.id': 'test-session-123',
+        'completion_prompt.error': 'Test error message'
+      });
+    });
+  });
+
+  describe('recordDelegationEvent', () => {
+    test('should record delegation event with type and data', () => {
+      const addEventSpy = jest.spyOn(tracer, 'addEvent');
+
+      tracer.recordDelegationEvent('started', { task: 'analyze code' });
+
+      expect(addEventSpy).toHaveBeenCalledWith('delegation.started', {
+        'session.id': 'test-session-123',
+        task: 'analyze code'
+      });
+    });
+  });
+
+  describe('recordJsonValidationEvent', () => {
+    test('should record JSON validation event with type and data', () => {
+      const addEventSpy = jest.spyOn(tracer, 'addEvent');
+
+      tracer.recordJsonValidationEvent('validation_started', { schema: 'user' });
+
+      expect(addEventSpy).toHaveBeenCalledWith('json_validation.validation_started', {
+        'session.id': 'test-session-123',
+        schema: 'user'
+      });
+    });
+  });
+
+  describe('recordMermaidValidationEvent', () => {
+    test('should record Mermaid validation event with type and data', () => {
+      const addEventSpy = jest.spyOn(tracer, 'addEvent');
+
+      tracer.recordMermaidValidationEvent('validation_complete', { valid: true });
+
+      expect(addEventSpy).toHaveBeenCalledWith('mermaid_validation.validation_complete', {
+        'session.id': 'test-session-123',
+        valid: true
+      });
+    });
+  });
+
+  describe('createSessionSpan', () => {
+    test('should create session span with attributes', () => {
+      const span = tracer.createSessionSpan({ 'custom.attr': 'value' });
+
+      expect(span).not.toBeNull();
+      expect(span.name).toBe('agent.session');
+      expect(span.attributes).toMatchObject({
+        'session.id': 'test-session-123',
+        'custom.attr': 'value'
+      });
+    });
+
+    test('should return null when tracer is disabled', () => {
+      const disabledTracer = new SimpleAppTracer(null);
+      const span = disabledTracer.createSessionSpan();
+
+      expect(span).toBeNull();
+    });
+  });
+
+  describe('createAISpan', () => {
+    test('should create AI span with model and provider', () => {
+      const span = tracer.createAISpan('gpt-4', 'openai', { 'custom.attr': 'value' });
+
+      expect(span).not.toBeNull();
+      expect(span.name).toBe('ai.request');
+      expect(span.attributes).toMatchObject({
+        'ai.model': 'gpt-4',
+        'ai.provider': 'openai',
+        'session.id': 'test-session-123',
+        'custom.attr': 'value'
+      });
+    });
+  });
+
+  describe('createToolSpan', () => {
+    test('should create tool span with tool name', () => {
+      const span = tracer.createToolSpan('search', { query: 'test' });
+
+      expect(span).not.toBeNull();
+      expect(span.name).toBe('tool.call');
+      expect(span.attributes).toMatchObject({
+        'tool.name': 'search',
+        'session.id': 'test-session-123',
+        query: 'test'
+      });
+    });
+  });
+
+  describe('withSpan', () => {
+    test('should execute function within span context', async () => {
+      let result;
+
+      result = await tracer.withSpan('test.operation', async () => {
+        return 'success';
+      }, { 'operation.type': 'test' });
+
+      expect(result).toBe('success');
+    });
+
+    test('should handle errors within span', async () => {
+      await expect(tracer.withSpan('test.operation', async () => {
+        throw new Error('Test error');
+      })).rejects.toThrow('Test error');
+    });
+
+    test('should execute function directly when tracer is disabled', async () => {
+      const disabledTracer = new SimpleAppTracer(null);
+
+      const result = await disabledTracer.withSpan('test.operation', async () => {
+        return 'executed';
+      });
+
+      expect(result).toBe('executed');
+    });
+  });
+});

package/data/probe/npm/tests/unit/simplified-attempt-completion.test.js

@@ -0,0 +1,274 @@
+/**
+ * Tests for simplified attempt_completion tool - without command parameter and JSON issues
+ */
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { attemptCompletionSchema } from '../../src/tools/common.js';
+import { parseXmlToolCallWithThinking } from '../../src/agent/tools.js';
+
+describe('Simplified attempt_completion Schema', () => {
+  test('should accept valid plain text result', () => {
+    const params = {
+      result: 'I have successfully analyzed the authentication system. It uses JWT tokens with RS256 encryption.'
+    };
+    
+    const validation = attemptCompletionSchema.safeParse(params);
+    expect(validation.success).toBe(true);
+    expect(validation.data.result).toBe(params.result);
+  });
+
+  test('should accept multiline text result', () => {
+    const params = {
+      result: `Analysis complete:
+
+1. The authentication system uses JWT tokens
+2. Password hashing is implemented with bcrypt
+3. Rate limiting is in place for login attempts
+
+Security recommendations:
+- Consider adding 2FA
+- Implement session timeout`
+    };
+    
+    const validation = attemptCompletionSchema.safeParse(params);
+    expect(validation.success).toBe(true);
+    expect(validation.data.result).toBe(params.result);
+  });
+
+  test('should accept empty result', () => {
+    const params = {
+      result: ''
+    };
+    
+    const validation = attemptCompletionSchema.safeParse(params);
+    expect(validation.success).toBe(true);
+  });
+
+  test('should reject missing result parameter', () => {
+    const params = {};
+    
+    const validation = attemptCompletionSchema.safeParse(params);
+    expect(validation.success).toBe(false);
+    expect(validation.error.issues[0].code).toBe('invalid_type');
+  });
+
+  test('should reject non-string result', () => {
+    const params = {
+      result: 123
+    };
+    
+    const validation = attemptCompletionSchema.safeParse(params);
+    expect(validation.success).toBe(false);
+  });
+
+  test('should not have command parameter in schema', () => {
+    // Test that the command parameter is no longer accepted
+    const params = {
+      result: 'Test result',
+      command: 'echo "test"'
+    };
+    
+    const validation = attemptCompletionSchema.safeParse(params);
+    expect(validation.success).toBe(true);
+    
+    // Command should be ignored (not present in validated data)
+    expect(validation.data).toEqual({ result: 'Test result' });
+    expect(validation.data.command).toBeUndefined();
+  });
+});
+
+describe('Simplified attempt_completion XML Parsing', () => {
+  test('should parse simple attempt_completion with direct content (no result wrapper)', () => {
+    const xml = `<attempt_completion>
+The authentication system has been analyzed successfully. It uses secure JWT tokens.
+</attempt_completion>`;
+
+    const parsed = parseXmlToolCallWithThinking(xml);
+
+    expect(parsed).toBeDefined();
+    expect(parsed.toolName).toBe('attempt_completion');
+    expect(parsed.params.result).toBe('The authentication system has been analyzed successfully. It uses secure JWT tokens.');
+  });
+
+  test('should parse multiline result with formatting', () => {
+    const xml = `<attempt_completion>
+Analysis Complete:
+
+**Security Findings:**
+- JWT tokens are properly signed
+- Password hashing uses bcrypt
+- Rate limiting is implemented
+
+**Recommendations:**
+1. Add 2FA support
+2. Implement session timeouts
+3. Add audit logging
+</attempt_completion>`;
+
+    const parsed = parseXmlToolCallWithThinking(xml);
+
+    expect(parsed).toBeDefined();
+    expect(parsed.toolName).toBe('attempt_completion');
+    expect(parsed.params.result).toContain('Analysis Complete:');
+    expect(parsed.params.result).toContain('**Security Findings:**');
+    expect(parsed.params.result).toContain('**Recommendations:**');
+  });
+
+  test('should handle result with code blocks', () => {
+    const xml = `<attempt_completion>
+I found the authentication function:
+
+\`\`\`javascript
+function authenticate(token) {
+  return jwt.verify(token, secret);
+}
+\`\`\`
+
+This function validates JWT tokens using the secret key.
+</attempt_completion>`;
+
+    const parsed = parseXmlToolCallWithThinking(xml);
+
+    expect(parsed).toBeDefined();
+    expect(parsed.toolName).toBe('attempt_completion');
+    expect(parsed.params.result).toContain('```javascript');
+    expect(parsed.params.result).toContain('function authenticate');
+  });
+
+  test('should handle result with XML-like content', () => {
+    const xml = `<attempt_completion>
+The config file contains: &lt;database&gt;&lt;host&gt;localhost&lt;/host&gt;&lt;/database&gt;
+</attempt_completion>`;
+
+    const parsed = parseXmlToolCallWithThinking(xml);
+
+    expect(parsed).toBeDefined();
+    // XML entities should remain as-is in the result (not decoded)
+    expect(parsed.params.result).toContain('&lt;database&gt;&lt;host&gt;localhost&lt;/host&gt;&lt;/database&gt;');
+  });
+
+  test('should treat all content as direct content (including old-style tags)', () => {
+    // Test that everything inside attempt_completion is treated as content
+    const xml = `<attempt_completion>
+<result>Analysis complete. The system is secure.</result>
+<command>echo "test"</command>
+</attempt_completion>`;
+
+    const parsed = parseXmlToolCallWithThinking(xml);
+
+    expect(parsed).toBeDefined();
+    expect(parsed.toolName).toBe('attempt_completion');
+    expect(parsed.params.result).toContain('Analysis complete. The system is secure.');
+    expect(parsed.params.result).toContain('<result>');
+    expect(parsed.params.result).toContain('<command>echo "test"</command>');
+    expect(parsed.params.command).toBeUndefined(); // Command should not be a separate parameter
+  });
+
+  test('should handle empty content', () => {
+    const xml = `<attempt_completion>
+</attempt_completion>`;
+
+    const parsed = parseXmlToolCallWithThinking(xml);
+
+    expect(parsed).toBeDefined();
+    expect(parsed.params.result).toBe('');
+  });
+
+  test('should handle content with special characters', () => {
+    const xml = `<attempt_completion>
+Found 5 files with "special" characters: @#$%^&*()[]{}|\\:";'<>?,./
+</attempt_completion>`;
+
+    const parsed = parseXmlToolCallWithThinking(xml);
+
+    expect(parsed).toBeDefined();
+    expect(parsed.params.result).toContain('special');
+    expect(parsed.params.result).toContain('@#$%^&*()[]{}|\\:');
+  });
+});
+
+describe('Integration with ProbeAgent (Mocked)', () => {
+  test('should handle valid attempt_completion without JSON validation', () => {
+    // Mock the schema validation that would happen in ProbeAgent
+    const params = {
+      result: 'The search functionality has been implemented successfully with BM25 ranking.'
+    };
+    
+    const validation = attemptCompletionSchema.safeParse(params);
+    expect(validation.success).toBe(true);
+    
+    // Simulate what ProbeAgent.js does - just extract the result
+    const finalResult = validation.data.result;
+    
+    expect(finalResult).toBe(params.result);
+    expect(typeof finalResult).toBe('string');
+  });
+
+  test('should handle attempt_completion with markdown formatting', () => {
+    const params = {
+      result: `# Authentication Analysis
+
+## Overview
+The system implements secure authentication using:
+- JWT tokens with RS256 signing
+- bcrypt password hashing
+- Rate limiting on login attempts
+
+## Security Score: A-
+
+The implementation follows security best practices.`
+    };
+    
+    const validation = attemptCompletionSchema.safeParse(params);
+    expect(validation.success).toBe(true);
+    
+    const finalResult = validation.data.result;
+    expect(finalResult).toContain('# Authentication Analysis');
+    expect(finalResult).toContain('## Security Score: A-');
+  });
+
+  test('should not require JSON cleaning or validation for plain text', () => {
+    // This test ensures we don't need the complex JSON cleaning logic anymore
+    const plainTextResult = 'Simple analysis result without any JSON formatting.';
+    
+    // Direct validation - no JSON parsing needed
+    const validation = attemptCompletionSchema.safeParse({ result: plainTextResult });
+    expect(validation.success).toBe(true);
+    
+    // No need for cleanSchemaResponse or validateJsonResponse
+    expect(validation.data.result).toBe(plainTextResult);
+  });
+});
+
+describe('Legacy Compatibility', () => {
+  test('should maintain backward compatibility with direct content format', () => {
+    // Ensure direct content attempt_completion XML works
+    const directXml = `<attempt_completion>
+Task completed successfully.
+</attempt_completion>`;
+
+    const parsed = parseXmlToolCallWithThinking(directXml);
+
+    expect(parsed).toBeDefined();
+    expect(parsed.toolName).toBe('attempt_completion');
+    expect(parsed.params.result).toBe('Task completed successfully.');
+  });
+
+  test('should handle content that includes old-style tags', () => {
+    // Content might include old-style tags, which should be treated as content now
+    const xmlWithOldTags = `<attempt_completion>
+Task completed.
+<command>npm test</command>
+</attempt_completion>`;
+
+    const parsed = parseXmlToolCallWithThinking(xmlWithOldTags);
+
+    expect(parsed).toBeDefined();
+    expect(parsed.toolName).toBe('attempt_completion');
+    expect(parsed.params.result).toContain('Task completed.');
+    expect(parsed.params.result).toContain('<command>npm test</command>');
+
+    // The result should include everything as content
+    const validation = attemptCompletionSchema.safeParse(parsed.params);
+    expect(validation.success).toBe(true);
+  });
+});