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

package/data/probe/examples/chat/test-hierarchy.js

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+
+import { TelemetryConfig } from './telemetry.js';
+import { appTracer } from './appTracer.js';
+import { extractImageUrls } from './probeChat.js';
+import { readFileSync, unlinkSync, existsSync } from 'fs';
+import { createHash } from 'crypto';
+
+/**
+ * Test to verify proper trace hierarchy with consistent trace IDs
+ */
+
+console.log('🔍 Testing Trace Hierarchy\n');
+
+const testTraceFile = './hierarchy-traces.jsonl';
+
+// Clean up any existing test files
+if (existsSync(testTraceFile)) {
+  unlinkSync(testTraceFile);
+}
+
+// Initialize telemetry
+const telemetryConfig = new TelemetryConfig({
+  serviceName: 'probe-chat',
+  serviceVersion: '1.0.0',
+  enableFile: true,
+  enableConsole: false,
+  enableRemote: false,
+  filePath: testTraceFile,
+});
+
+telemetryConfig.initialize();
+
+console.log('✅ Telemetry initialized');
+
+async function testTraceHierarchy() {
+  const sessionId = 'test-session-123';
+  const messageId = 'test-msg-456';
+  const message = 'Here is an image: https://github.com/user-attachments/assets/example.png';
+  
+  // Calculate expected trace ID for verification
+  const expectedTraceId = createHash('sha256').update(sessionId).digest('hex').substring(0, 32);
+  console.log(`📋 Session ID: ${sessionId}`);
+  console.log(`📋 Expected Trace ID: ${expectedTraceId}`);
+
+  console.log('📝 Creating hierarchical test traces...');
+
+  // Start a chat session
+  const sessionSpan = appTracer.startChatSession(sessionId, message, 'anthropic', 'claude-3-7-sonnet-20250219');
+  
+  // Start user message processing within session context
+  await appTracer.withSessionContext(sessionId, async () => {
+    const userProcessingSpan = appTracer.startUserMessageProcessing(sessionId, messageId, message, 1);
+    
+    // Extract image URLs within user processing context
+    const result = await appTracer.withUserProcessingContext(sessionId, async () => {
+      return await extractImageUrls(message, true);
+    });
+    
+    console.log('✅ extractImageUrls result:', result);
+    
+    // Start agent loop within user processing context
+    appTracer.withUserProcessingContext(sessionId, () => {
+      appTracer.startAgentLoop(sessionId, 5);
+      
+      // Start iteration within agent loop context
+      appTracer.withAgentLoopContext(sessionId, () => {
+        appTracer.startAgentIteration(sessionId, 1, 3, 1000);
+        
+        // Start AI request within iteration context
+        appTracer.withIterationContext(sessionId, 1, () => {
+          const aiRequestSpan = appTracer.startAiGenerationRequest(sessionId, 1, 'claude-3-7-sonnet-20250219', 'anthropic', {
+            temperature: 0.3,
+            maxTokens: 1000,
+            maxRetries: 2
+          });
+          
+          // End AI request
+          appTracer.endAiRequest(sessionId, 1, true);
+        });
+        
+        // End iteration
+        appTracer.endIteration(sessionId, 1, true, 'completion');
+      });
+      
+      // End agent loop
+      appTracer.endAgentLoop(sessionId, 1, true, 'completion');
+    });
+    
+    // End user processing
+    appTracer.endUserMessageProcessing(sessionId, true);
+  });
+  
+  // End chat session
+  appTracer.endChatSession(sessionId, true, 1500);
+  
+  console.log('✅ All spans created and ended');
+}
+
+// Run the test
+try {
+  await testTraceHierarchy();
+  
+  // Force flush the spans
+  await telemetryConfig.sdk.getTracerProvider().forceFlush();
+  
+  // Give it time to write to file
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  
+  console.log('\n🔍 Verifying trace hierarchy...');
+  
+  if (existsSync(testTraceFile)) {
+    const traceData = readFileSync(testTraceFile, 'utf8');
+    const traceLines = traceData.split('\n').filter(Boolean);
+    
+    console.log(`✅ Found ${traceLines.length} trace entries`);
+    
+    if (traceLines.length > 0) {
+      const traces = traceLines.map(line => JSON.parse(line));
+      
+      // Group spans by trace ID
+      const traceGroups = {};
+      traces.forEach(trace => {
+        if (!traceGroups[trace.traceId]) {
+          traceGroups[trace.traceId] = [];
+        }
+        traceGroups[trace.traceId].push(trace);
+      });
+      
+      console.log(`\n📊 Trace Analysis:`);
+      console.log(`  ✓ Total spans: ${traces.length}`);
+      console.log(`  ✓ Unique trace IDs: ${Object.keys(traceGroups).length}`);
+      
+      // Verify all spans belong to the same trace
+      if (Object.keys(traceGroups).length === 1) {
+        console.log(`  ✅ SUCCESS: All spans belong to the same trace ID!`);
+        
+        const traceId = Object.keys(traceGroups)[0];
+        const spans = traceGroups[traceId];
+        
+        console.log(`\n🔗 Trace ID: ${traceId}`);
+        console.log(`📋 Spans in hierarchy:`);
+        
+        // Sort spans by start time to show hierarchy
+        spans.sort((a, b) => a.startTimeUnixNano - b.startTimeUnixNano);
+        
+        spans.forEach((span, index) => {
+          const hasParent = span.parentSpanId ? '└─' : '┌─';
+          console.log(`  ${hasParent} [${index + 1}] ${span.name}`);
+          console.log(`      Span ID: ${span.spanId}`);
+          if (span.parentSpanId) {
+            console.log(`      Parent: ${span.parentSpanId}`);
+          }
+          console.log(`      Status: ${span.status?.code === 1 ? 'OK' : span.status?.code === 2 ? 'ERROR' : 'UNKNOWN'}`);
+        });
+        
+        // Verify parent-child relationships
+        let parentChildRelationships = 0;
+        spans.forEach(span => {
+          if (span.parentSpanId) {
+            const parentExists = spans.some(s => s.spanId === span.parentSpanId);
+            if (parentExists) {
+              parentChildRelationships++;
+            } else {
+              console.log(`    ⚠️  Span ${span.name} has invalid parent reference`);
+            }
+          }
+        });
+        
+        console.log(`\n✅ Parent-child relationships verified: ${parentChildRelationships}/${spans.length - 1} spans have valid parents`);
+        
+      } else {
+        console.log(`  ❌ FAILURE: Spans are spread across ${Object.keys(traceGroups).length} different trace IDs`);
+        
+        Object.entries(traceGroups).forEach(([traceId, spans]) => {
+          console.log(`    Trace ${traceId}: ${spans.length} spans`);
+          spans.forEach(span => {
+            console.log(`      - ${span.name}`);
+          });
+        });
+      }
+    }
+    
+    console.log('\n🎉 Hierarchy test completed!');
+    
+  } else {
+    console.log('❌ Trace file was not created');
+  }
+  
+} catch (error) {
+  console.error('❌ Test failed:', error);
+} finally {
+  // Clean up
+  await telemetryConfig.shutdown();
+  console.log('\n🧹 Telemetry shutdown complete');
+  
+  // Keep the trace file for manual inspection
+  if (existsSync(testTraceFile)) {
+    console.log(`📁 Trace file preserved: ${testTraceFile}`);
+  }
+}
+
+console.log('\n✅ Trace hierarchy test completed!');

package/data/probe/examples/chat/test-image-spans.js

@@ -0,0 +1,37 @@
+import { ProbeChat } from './probeChat.js';
+
+// Test image extraction with OpenTelemetry spans
+async function testImageExtraction() {
+  console.log('Testing image extraction with OpenTelemetry spans...\n');
+  
+  try {
+    // Create a ProbeChat instance with no API keys mode
+    const probeChat = new ProbeChat({
+      debug: true,
+      noApiKeysMode: true
+    });
+    
+    // Test message with images
+    const testMessage = `
+      Here are some images:
+      - GitHub asset: https://github.com/user-attachments/assets/example.png
+      - Private image: https://private-user-images.githubusercontent.com/123/example.jpg
+      - Regular image: https://example.com/photo.jpeg
+      
+      And some text without images.
+    `;
+    
+    console.log('🔍 Testing chat with images (no API keys mode)...');
+    const result = await probeChat.chat(testMessage);
+    console.log('✅ Chat completed successfully');
+    console.log('📄 Response:', result.response.substring(0, 100) + '...');
+    
+    // Test completed
+    console.log('\n🎉 Test completed! Check test-image-spans.jsonl for trace data.');
+    
+  } catch (error) {
+    console.error('❌ Test failed:', error.message);
+  }
+}
+
+testImageExtraction().catch(console.error);

package/data/probe/examples/chat/test-local-image-reading.js

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+
+/**
+ * NOTE: This is a standalone test file. The MIME types and regex patterns below
+ * are duplicated from @probelabs/probe/agent/imageConfig for self-containment.
+ * When modifying image support, update both the shared config and this file.
+ */
+
+import { writeFileSync, unlinkSync, existsSync, readFileSync } from 'fs';
+import { resolve, isAbsolute } from 'path';
+
+// Mock the extractImageUrls function for testing (to avoid API key requirements)
+// MIME types duplicated from @probelabs/probe/agent/imageConfig (keep in sync!)
+async function extractImageUrls(message, debug = false) {
+  const imageUrlPattern = /(?:data:image\/[a-zA-Z]*;base64,[A-Za-z0-9+/=]+|https?:\/\/(?:(?:private-user-images\.githubusercontent\.com|github\.com\/user-attachments\/assets)\/[^\s"'<>]+|[^\s"'<>]+\.(?:png|jpg|jpeg|webp|bmp|svg)(?:\?[^\s"'<>]*)?)|(?:\.?\.?\/)?[^\s"'<>]*\.(?:png|jpg|jpeg|webp|bmp|svg))/gi;
+
+  const urls = [];
+  const foundPatterns = [];
+  let match;
+
+  while ((match = imageUrlPattern.exec(message)) !== null) {
+    foundPatterns.push(match[0]);
+    if (debug) {
+      console.log(`[DEBUG] Found image pattern: ${match[0]}`);
+    }
+  }
+
+  // Process each found pattern
+  for (const pattern of foundPatterns) {
+    if (pattern.startsWith('http') || pattern.startsWith('data:image/')) {
+      urls.push(pattern);
+      if (debug) {
+        console.log(`[DEBUG] Using URL/base64 as-is: ${pattern.substring(0, 50)}...`);
+      }
+    } else {
+      // Local file path - convert to base64
+      try {
+        const absolutePath = isAbsolute(pattern) ? pattern : resolve(process.cwd(), pattern);
+        
+        if (!existsSync(absolutePath)) {
+          if (debug) console.log(`[DEBUG] File not found: ${absolutePath}`);
+          continue;
+        }
+
+        const extension = absolutePath.toLowerCase().split('.').pop();
+        // MIME types from @probelabs/probe/agent/imageConfig (keep in sync!)
+        const mimeTypes = {
+          'png': 'image/png',
+          'jpg': 'image/jpeg',
+          'jpeg': 'image/jpeg',
+          'webp': 'image/webp',
+          'bmp': 'image/bmp',
+          'svg': 'image/svg+xml'
+        };
+        
+        const mimeType = mimeTypes[extension];
+        if (!mimeType) {
+          if (debug) console.log(`[DEBUG] Unsupported format: ${extension}`);
+          continue;
+        }
+
+        const fileBuffer = readFileSync(absolutePath);
+        const base64Data = fileBuffer.toString('base64');
+        const dataUrl = `data:${mimeType};base64,${base64Data}`;
+        urls.push(dataUrl);
+        
+        if (debug) {
+          console.log(`[DEBUG] Converted ${pattern} to base64 (${fileBuffer.length} bytes)`);
+        }
+      } catch (error) {
+        if (debug) {
+          console.log(`[DEBUG] Error processing ${pattern}: ${error.message}`);
+        }
+      }
+    }
+  }
+
+  // Clean message
+  let cleanedMessage = message;
+  foundPatterns.forEach(pattern => {
+    cleanedMessage = cleanedMessage.replace(pattern, '').trim();
+  });
+  cleanedMessage = cleanedMessage.replace(/\s+/g, ' ').trim();
+
+  return { urls, cleanedMessage };
+}
+
+/**
+ * Test to verify local image file reading functionality
+ */
+
+console.log('🖼️  Testing Local Image File Reading\n');
+
+async function testLocalImageReading() {
+  try {
+    // Create a simple test image file (1x1 PNG)
+    const testImagePath = './test-image.png';
+    const simplePngBuffer = Buffer.from([
+      0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, // PNG signature
+      0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52, // IHDR chunk
+      0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, // 1x1 dimensions
+      0x08, 0x06, 0x00, 0x00, 0x00, 0x1F, 0x15, 0xC4,
+      0x89, 0x00, 0x00, 0x00, 0x0D, 0x49, 0x44, 0x41, // IDAT chunk
+      0x54, 0x78, 0x9C, 0x62, 0x00, 0x02, 0x00, 0x00,
+      0x05, 0x00, 0x01, 0x0D, 0x0A, 0x2D, 0xB4, 0x00,
+      0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, // IEND chunk
+      0x42, 0x60, 0x82
+    ]);
+
+    // Write test image
+    writeFileSync(testImagePath, simplePngBuffer);
+    console.log(`✅ Created test image: ${testImagePath}`);
+
+    // Test 1: Local file path extraction
+    console.log('\n📋 Test 1: Local file path in message');
+    const message1 = `Please analyze this image: ${testImagePath} and tell me about it.`;
+    const result1 = await extractImageUrls(message1, true);
+    
+    console.log(`Found ${result1.urls.length} images`);
+    if (result1.urls.length > 0) {
+      console.log(`✅ Successfully converted local file to base64`);
+      console.log(`   Original: ${testImagePath}`);
+      console.log(`   Base64 length: ${result1.urls[0].length} characters`);
+      console.log(`   Data URL prefix: ${result1.urls[0].substring(0, 30)}...`);
+    } else {
+      console.log('❌ No images found');
+    }
+    console.log(`Cleaned message: "${result1.cleanedMessage}"`);
+
+    // Test 2: Mixed URLs and local files
+    console.log('\n📋 Test 2: Mixed URLs and local files');
+    const message2 = `Compare ${testImagePath} with https://example.com/remote.png`;
+    const result2 = await extractImageUrls(message2, true);
+    
+    console.log(`Found ${result2.urls.length} images`);
+    console.log(`Cleaned message: "${result2.cleanedMessage}"`);
+
+    // Test 3: Relative paths
+    console.log('\n📋 Test 3: Relative path variations');
+    const messages = [
+      `Image at ./test-image.png`,
+      `Image at ../examples/chat/test-image.png`,
+      `Image at test-image.png`
+    ];
+    
+    for (const msg of messages) {
+      const result = await extractImageUrls(msg, true);
+      console.log(`"${msg}" -> ${result.urls.length} images found`);
+    }
+
+    // Test 4: Security - try to access file outside allowed directory
+    console.log('\n📋 Test 4: Security validation');
+    const securityTestMessage = 'Look at this image: /etc/passwd.png';
+    const securityResult = await extractImageUrls(securityTestMessage, true);
+    console.log(`Security test: ${securityResult.urls.length} images found (should be 0)`);
+
+    // Test 5: Non-existent file
+    console.log('\n📋 Test 5: Non-existent file');
+    const missingFileMessage = 'Check this image: ./missing-image.png';
+    const missingResult = await extractImageUrls(missingFileMessage, true);
+    console.log(`Missing file test: ${missingResult.urls.length} images found (should be 0)`);
+
+    // Cleanup
+    if (existsSync(testImagePath)) {
+      unlinkSync(testImagePath);
+      console.log('\n🧹 Cleaned up test image');
+    }
+
+    console.log('\n🎉 Local image reading tests completed!');
+
+  } catch (error) {
+    console.error('❌ Test failed:', error);
+  }
+}
+
+testLocalImageReading().catch(console.error);

package/data/probe/examples/chat/test-mcp-integration.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+
+/**
+ * Test script to verify MCP integration with XML syntax
+ */
+
+import { MCPXmlBridge, parseXmlMcpToolCall, parseHybridXmlToolCall } from '@probelabs/probe/agent/mcp';
+
+console.log('Testing MCP XML Integration...\n');
+
+// Test 1: Parse MCP tool call with JSON parameters
+console.log('Test 1: Parse MCP tool call with JSON params');
+const mcpXml = `
+<mcp_filesystem_read>
+<params>
+{
+  "path": "/etc/hosts",
+  "encoding": "utf-8"
+}
+</params>
+</mcp_filesystem_read>
+`;
+
+const parsed = parseXmlMcpToolCall(mcpXml, ['mcp_filesystem_read']);
+if (parsed && parsed.toolName === 'mcp_filesystem_read' && parsed.params.path === '/etc/hosts') {
+  console.log('✅ Test 1 PASSED: MCP tool parsed correctly with JSON params\n');
+} else {
+  console.log('❌ Test 1 FAILED:', parsed, '\n');
+}
+
+// Test 2: Parse native tool call with XML parameters
+console.log('Test 2: Parse native tool call with XML params');
+const nativeXml = `
+<search>
+<query>authentication</query>
+<path>./src</path>
+</search>
+`;
+
+const nativeParsed = parseHybridXmlToolCall(nativeXml, ['search']);
+if (nativeParsed && nativeParsed.toolName === 'search' && nativeParsed.params.query === 'authentication') {
+  console.log('✅ Test 2 PASSED: Native tool parsed correctly with XML params\n');
+} else {
+  console.log('❌ Test 2 FAILED:', nativeParsed, '\n');
+}
+
+// Test 3: Create MCP bridge and generate tool definitions
+console.log('Test 3: MCP Bridge tool definition generation');
+const bridge = new MCPXmlBridge({ debug: false });
+
+// Simulate adding a tool
+bridge.mcpTools['test_tool'] = {
+  description: 'A test MCP tool',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      message: { type: 'string', description: 'Test message' },
+      count: { type: 'number', description: 'Count value' }
+    },
+    required: ['message']
+  }
+};
+
+bridge.xmlDefinitions['test_tool'] = bridge.constructor.prototype.constructor.mcpToolToXmlDefinition ||
+  `## test_tool
+Description: A test MCP tool
+
+Parameters (provide as JSON object):
+- message: string (required) - Test message
+- count: number (optional) - Count value
+
+Usage:
+<test_tool>
+<params>
+{
+  "message": "hello",
+  "count": 42
+}
+</params>
+</test_tool>`;
+
+const xmlDef = bridge.getXmlToolDefinitions();
+if (xmlDef.includes('test_tool') && xmlDef.includes('JSON object')) {
+  console.log('✅ Test 3 PASSED: XML definitions generated correctly\n');
+} else {
+  console.log('❌ Test 3 FAILED: XML definitions not correct\n');
+}
+
+// Test 4: Test hybrid parsing with both tool types
+console.log('Test 4: Hybrid parsing with MCP bridge');
+const hybridXml1 = `
+<test_tool>
+<params>
+{"message": "test", "count": 10}
+</params>
+</test_tool>
+`;
+
+const hybridResult = parseHybridXmlToolCall(hybridXml1, ['search', 'query'], bridge);
+if (hybridResult && hybridResult.type === 'mcp' && hybridResult.params.message === 'test') {
+  console.log('✅ Test 4 PASSED: Hybrid parser correctly identified MCP tool\n');
+} else {
+  console.log('❌ Test 4 FAILED:', hybridResult, '\n');
+}
+
+// Test 5: Test parsing with thinking tags (should be ignored)
+console.log('Test 5: Parse with thinking tags');
+const xmlWithThinking = `
+<thinking>
+I need to search for authentication code.
+Let me use the search tool.
+</thinking>
+<search>
+<query>auth</query>
+</search>
+`;
+
+const thinkingParsed = parseHybridXmlToolCall(xmlWithThinking, ['search']);
+if (thinkingParsed && thinkingParsed.toolName === 'search' && thinkingParsed.params.query === 'auth') {
+  console.log('✅ Test 5 PASSED: Thinking tags correctly ignored\n');
+} else {
+  console.log('❌ Test 5 FAILED:', thinkingParsed, '\n');
+}
+
+console.log('=== MCP Integration Test Summary ===');
+console.log('The MCP-XML bridge is working correctly!');
+console.log('\nKey features tested:');
+console.log('1. MCP tools with JSON parameters in <params> tag');
+console.log('2. Native tools with XML parameters');
+console.log('3. XML tool definition generation for system prompts');
+console.log('4. Hybrid parsing supporting both tool types');
+console.log('5. Thinking tag filtering');
+console.log('\nThe Probe agent can now:');
+console.log('- Use native tools with XML syntax: <tool><param>value</param></tool>');
+console.log('- Use MCP tools with JSON syntax: <mcp_tool><params>{"key": "value"}</params></mcp_tool>');
+console.log('- Connect to external MCP servers for additional capabilities');