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

package/data/probe/npm/tests/mcp-strict-syntax.test.js

@@ -0,0 +1,319 @@
+/**
+ * Tests for MCP server with strict elastic syntax validation
+ *
+ * Note: These tests use the freshly compiled probe binary from the workspace.
+ * In CI, the binary will be built before tests run.
+ */
+
+import { search } from '../src/search.js';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { fileURLToPath } from 'url';
+
+const execAsync = promisify(exec);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Get the workspace root (one level up from npm/)
+const workspaceRoot = path.resolve(__dirname, '..', '..');
+const npmBinDir = path.join(__dirname, '..', 'bin');
+
+/**
+ * Copy the freshly built binary from workspace to npm bin directory
+ */
+async function copyFreshBinary() {
+  try {
+    // Check for release binary first, then debug
+    const possibleBinaries = [
+      path.join(workspaceRoot, 'target', 'release', 'probe'),
+      path.join(workspaceRoot, 'target', 'debug', 'probe'),
+    ];
+
+    let sourceBinary = null;
+    for (const binPath of possibleBinaries) {
+      if (fs.existsSync(binPath)) {
+        sourceBinary = binPath;
+        console.log(`   ✓ Found fresh binary at: ${binPath}`);
+        break;
+      }
+    }
+
+    if (!sourceBinary) {
+      console.log('   ⚠️  No fresh binary found in target/release or target/debug');
+      console.log('   ℹ️  Run "cargo build --release" or "cargo build" to build the binary');
+      return false;
+    }
+
+    // Ensure bin directory exists
+    await fs.promises.mkdir(npmBinDir, { recursive: true });
+
+    // Copy to npm bin directory
+    const targetBinary = path.join(npmBinDir, 'probe-binary');
+    await fs.promises.copyFile(sourceBinary, targetBinary);
+    await fs.promises.chmod(targetBinary, 0o755);
+
+    console.log(`   ✓ Copied fresh binary to: ${targetBinary}`);
+    return true;
+  } catch (error) {
+    console.error(`   ✗ Error copying fresh binary: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Check if the binary supports --strict-elastic-syntax flag
+ */
+async function binarySupportsStrictSyntax() {
+  try {
+    const binaryPath = path.join(npmBinDir, 'probe-binary');
+    if (!fs.existsSync(binaryPath)) {
+      return false;
+    }
+
+    const { stdout } = await execAsync(`"${binaryPath}" search --help`);
+    return stdout.includes('--strict-elastic-syntax');
+  } catch (error) {
+    return false;
+  }
+}
+
+describe('MCP Strict Elastic Syntax', () => {
+  let tempDir;
+  let skipTests = false;
+
+  beforeAll(async () => {
+    console.log('\n🔧 Setting up MCP strict syntax tests...');
+
+    // Try to copy fresh binary
+    const copiedFresh = await copyFreshBinary();
+
+    if (!copiedFresh) {
+      console.log('   ⚠️  Using existing binary (if available)');
+    }
+
+    // Check if binary supports the flag
+    skipTests = !(await binarySupportsStrictSyntax());
+
+    if (skipTests) {
+      console.log('   ⚠️  Binary does not support --strict-elastic-syntax flag');
+      console.log('   ℹ️  These tests will be skipped');
+      console.log('   💡 To run tests, build the binary first: cargo build --release\n');
+    } else {
+      console.log('   ✓ Binary supports --strict-elastic-syntax flag');
+      console.log('   ✓ All tests will run\n');
+    }
+  });
+
+  beforeEach(() => {
+    if (skipTests) return;
+
+    // Create a temporary directory for test files
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'probe-mcp-test-'));
+
+    // Create test files with various patterns
+    const testFile = path.join(tempDir, 'test.js');
+    fs.writeFileSync(testFile, `
+function getUserId(user) {
+  return user.id;
+}
+
+function get_user_name(user) {
+  return user.name;
+}
+
+function errorHandler(err) {
+  console.error('Error:', err);
+}
+
+function handleError(err) {
+  errorHandler(err);
+}
+`);
+  });
+
+  afterEach(() => {
+    if (skipTests) return;
+
+    // Clean up temp directory
+    if (tempDir && fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  test('rejects vague query with strict syntax enabled', async () => {
+    if (skipTests) {
+      console.log('   ⊘ Skipped: binary does not support --strict-elastic-syntax yet');
+      return;
+    }
+
+    await expect(
+      search({
+        path: tempDir,
+        query: 'error handler', // Vague query
+        strictElasticSyntax: true,
+        maxResults: 1,
+        timeout: 10
+      })
+    ).rejects.toThrow(/Vague query format detected/);
+  });
+
+  test('rejects unquoted snake_case with strict syntax enabled', async () => {
+    if (skipTests) {
+      console.log('   ⊘ Skipped: binary does not support --strict-elastic-syntax yet');
+      return;
+    }
+
+    await expect(
+      search({
+        path: tempDir,
+        query: 'get_user_name', // Unquoted snake_case
+        strictElasticSyntax: true,
+        maxResults: 1,
+        timeout: 10
+      })
+    ).rejects.toThrow(/contains special characters/);
+  });
+
+  test('rejects unquoted camelCase with strict syntax enabled', async () => {
+    if (skipTests) {
+      console.log('   ⊘ Skipped: binary does not support --strict-elastic-syntax yet');
+      return;
+    }
+
+    await expect(
+      search({
+        path: tempDir,
+        query: 'getUserId', // Unquoted camelCase
+        strictElasticSyntax: true,
+        maxResults: 1,
+        timeout: 10
+      })
+    ).rejects.toThrow(/contains special characters/);
+  });
+
+  test('accepts explicit operators with strict syntax enabled', async () => {
+    if (skipTests) {
+      console.log('   ⊘ Skipped: binary does not support --strict-elastic-syntax yet');
+      return;
+    }
+
+    const result = await search({
+      path: tempDir,
+      query: '(error AND handler)',
+      strictElasticSyntax: true,
+      maxResults: 1,
+      timeout: 10
+    });
+
+    expect(result).toBeDefined();
+    expect(typeof result).toBe('string');
+  });
+
+  test('accepts quoted snake_case with strict syntax enabled', async () => {
+    if (skipTests) {
+      console.log('   ⊘ Skipped: binary does not support --strict-elastic-syntax yet');
+      return;
+    }
+
+    const result = await search({
+      path: tempDir,
+      query: '"get_user_name"',
+      strictElasticSyntax: true,
+      maxResults: 1,
+      timeout: 10
+    });
+
+    expect(result).toBeDefined();
+    expect(typeof result).toBe('string');
+  });
+
+  test('accepts quoted camelCase with strict syntax enabled', async () => {
+    if (skipTests) {
+      console.log('   ⊘ Skipped: binary does not support --strict-elastic-syntax yet');
+      return;
+    }
+
+    const result = await search({
+      path: tempDir,
+      query: '"getUserId"',
+      strictElasticSyntax: true,
+      maxResults: 1,
+      timeout: 10
+    });
+
+    expect(result).toBeDefined();
+    expect(typeof result).toBe('string');
+  });
+
+  test('accepts single word with strict syntax enabled', async () => {
+    if (skipTests) {
+      console.log('   ⊘ Skipped: binary does not support --strict-elastic-syntax yet');
+      return;
+    }
+
+    const result = await search({
+      path: tempDir,
+      query: 'error',
+      strictElasticSyntax: true,
+      maxResults: 1,
+      timeout: 10
+    });
+
+    expect(result).toBeDefined();
+    expect(typeof result).toBe('string');
+  });
+
+  test('accepts complex query with strict syntax enabled', async () => {
+    if (skipTests) {
+      console.log('   ⊘ Skipped: binary does not support --strict-elastic-syntax yet');
+      return;
+    }
+
+    const result = await search({
+      path: tempDir,
+      query: '("getUserId" AND NOT test)',
+      strictElasticSyntax: true,
+      maxResults: 1,
+      timeout: 10
+    });
+
+    expect(result).toBeDefined();
+    expect(typeof result).toBe('string');
+  });
+
+  test('allows vague query when strict syntax is disabled', async () => {
+    // This test doesn't require the strict flag, so it always runs
+    if (!tempDir) {
+      tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'probe-mcp-test-'));
+    }
+
+    const result = await search({
+      path: tempDir,
+      query: 'error handler', // Vague query but flag not set
+      strictElasticSyntax: false,
+      maxResults: 1,
+      timeout: 10
+    });
+
+    expect(result).toBeDefined();
+    expect(typeof result).toBe('string');
+  });
+
+  test('MCP default behavior disables strict syntax', () => {
+    // This is a static test, always runs
+    const mcpOptions = {
+      path: '/some/path',
+      query: 'test',
+      allowTests: true,
+      session: "new",
+      maxResults: 20,
+      maxTokens: 8000,
+      strictElasticSyntax: false, // This is the MCP default (relaxed syntax)
+    };
+
+    expect(mcpOptions.strictElasticSyntax).toBe(false);
+  });
+});

package/data/probe/npm/tests/mermaidQuoteEscaping.test.js

@@ -0,0 +1,214 @@
+/**
+ * Mermaid Quote Handling Tests - Updated for maid integration
+ *
+ * NOTE: This test file has been significantly updated for maid 0.0.6 integration.
+ * Many tests from the old regex-based validation have been REMOVED because:
+ * 1. Maid has different quote handling than the old manual logic
+ * 2. Maid doesn't support escaped quotes (\") - requires HTML entities
+ * 3. Maid cannot auto-fix some quote patterns that the old logic could
+ *
+ * Removed tests checked OLD behavior that maid doesn't support.
+ * See: https://github.com/probelabs/maid/issues/18 for maid limitations
+ */
+
+import { validateAndFixMermaidResponse, validateMermaidDiagram, decodeHtmlEntities } from '../src/agent/schemaUtils.js';
+
+describe('Mermaid Quote Escaping - Maid Integration Tests', () => {
+
+  describe('Basic Quote Validation', () => {
+    test('should validate diagrams with properly quoted labels', async () => {
+      const diagram = `
+        \`\`\`mermaid
+        graph TD
+          A["Task with quotes"]
+          B["Process with data"]
+        \`\`\`
+      `;
+
+      const result = await validateAndFixMermaidResponse(diagram, { autoFix: true });
+
+      expect(result.isValid).toBe(true);
+    });
+
+
+  });
+
+  describe('HTML Entity Handling', () => {
+    test('should accept HTML entities in labels', async () => {
+      const diagram = `
+        \`\`\`mermaid
+        graph TD
+          A[It's a test]
+          B[Process "data" file]
+        \`\`\`
+      `;
+
+      const result = await validateAndFixMermaidResponse(diagram, { autoFix: true });
+
+      expect(result.isValid).toBe(true);
+    });
+
+
+
+    test('should not double-encode existing ' entities', async () => {
+      const diagram = `
+        \`\`\`mermaid
+        graph TD
+          A[It's already encoded]
+        \`\`\`
+      `;
+
+      const result = await validateAndFixMermaidResponse(diagram, { autoFix: true });
+
+      expect(result.isValid).toBe(true);
+      expect(result.fixedResponse).not.toContain(''');
+    });
+
+  });
+
+  describe('Quoted Labels', () => {
+
+  });
+
+  describe('Edge Cases', () => {
+    test('should handle empty quotes', async () => {
+      const diagram = `
+        \`\`\`mermaid
+        graph TD
+          A[""]
+          B[" "]
+        \`\`\`
+      `;
+
+      const result = await validateAndFixMermaidResponse(diagram, { autoFix: true });
+
+      expect(result.isValid).toBe(true);
+    });
+
+    test('should handle properly quoted content', async () => {
+      const diagram = `
+        \`\`\`mermaid
+        graph TD
+          A["start and end"]
+          B["Content here"]
+        \`\`\`
+      `;
+
+      const result = await validateAndFixMermaidResponse(diagram, { autoFix: true });
+
+      expect(result.isValid).toBe(true);
+    });
+
+
+    test('should handle quotes in different node types with proper quoting', async () => {
+      const diagram = `
+        \`\`\`mermaid
+        graph TD
+          A["Square with quotes"]
+          B{"Diamond with 'quotes'"}
+          C(["Database with "quotes""])
+        \`\`\`
+      `;
+
+      const result = await validateAndFixMermaidResponse(diagram, { autoFix: true });
+
+      expect(result.isValid).toBe(true);
+    });
+  });
+
+  describe('Real-World Scenarios', () => {
+
+    test('should handle JSON-like content with proper quoting', async () => {
+      const diagram = `
+        \`\`\`mermaid
+        graph TD
+          A["Parse data structure"]
+          B["Config items"]
+        \`\`\`
+      `;
+
+      const result = await validateAndFixMermaidResponse(diagram, { autoFix: true });
+
+      expect(result.isValid).toBe(true);
+    });
+
+    test('should handle file paths with quotes', async () => {
+      const diagram = `
+        \`\`\`mermaid
+        graph TD
+          A["Read file path"]
+          B["Write file path"]
+        \`\`\`
+      `;
+
+      const result = await validateAndFixMermaidResponse(diagram, { autoFix: true });
+
+      expect(result.isValid).toBe(true);
+    });
+
+  });
+
+  describe('HTML Entity Decoder Tests', () => {
+    test('should decode all supported HTML entities', () => {
+      const input = '<tag> & "text" 'data' 'test'  space';
+      const expected = '<tag> & "text" \'data\' \'test\'  space';
+
+      expect(decodeHtmlEntities(input)).toBe(expected);
+    });
+
+    test('should handle null and undefined gracefully', () => {
+      expect(decodeHtmlEntities(null)).toBe(null);
+      expect(decodeHtmlEntities(undefined)).toBe(undefined);
+      expect(decodeHtmlEntities('')).toBe('');
+    });
+
+    test('should decode entities multiple times in same string', () => {
+      const input = '&quot;one&quot; and &quot;two&quot; and &quot;three&quot;';
+      const expected = '"one" and "two" and "three"';
+
+      expect(decodeHtmlEntities(input)).toBe(expected);
+    });
+  });
+
+  describe('Validation Without Auto-Fix', () => {
+    test('should validate diagrams with quotes as valid when appropriate', async () => {
+      const validDiagram = `graph TD
+        A["Valid quoted label"]
+        B[Regular label]
+`;
+
+      const result = await validateMermaidDiagram(validDiagram);
+
+      expect(result.isValid).toBe(true);
+    });
+
+  });
+
+  describe('Multiple Diagrams', () => {
+    test('should handle multiple diagrams with proper quoting', async () => {
+      const response = `
+        Here's the first diagram:
+        \`\`\`mermaid
+        graph TD
+          A["First with quotes"]
+          B["First with data"]
+        \`\`\`
+
+        And here's the second:
+        \`\`\`mermaid
+        graph LR
+          C["Second with &apos;entities&apos;"]
+          D["Second with &quot;entities&quot;"]
+        \`\`\`
+      `;
+
+      const result = await validateAndFixMermaidResponse(response, { autoFix: true });
+
+      expect(result.isValid).toBe(true);
+      expect(result.diagrams).toHaveLength(2);
+    });
+  });
+
+  describe('Performance', () => {
+  });
+});

package/data/probe/npm/tests/nestedQuoteFix.test.js

@@ -0,0 +1,40 @@
+/**
+ * Nested Quote Fix Tests
+ *
+ * NOTE: Most tests in this file have been skipped for maid 0.0.6 integration.
+ * These tests check OLD regex-based HTML entity handling and quote fixing behavior:
+ * - Converting ' to '
+ * - Automatic quote wrapping with escaped inner quotes
+ * - Specific HTML entity normalization
+ *
+ * Maid handles HTML entities and quotes differently using proper parsing.
+ * Tests marked with .skip check OLD behavior that maid doesn't replicate.
+ */
+
+import { validateAndFixMermaidResponse } from '../src/agent/schemaUtils.js';
+
+
+
+test('should not double-encode already encoded entities', async () => {
+  const preEncodedDiagram = `
+    \`\`\`mermaid
+    graph TD
+      A[Text with 'single' quotes]
+      B[Text with "double" quotes]
+    \`\`\`
+  `;
+
+  const result = await validateAndFixMermaidResponse(preEncodedDiagram, {
+    autoFix: true,
+    debug: false
+  });
+
+  expect(result.isValid).toBe(true);
+  
+  // Should not double-encode
+  expect(result.fixedResponse).not.toContain(''');
+  expect(result.fixedResponse).not.toContain('"');
+});
+
+
+

package/data/probe/npm/tests/setup.js

@@ -0,0 +1,46 @@
+/**
+ * Jest setup file
+ * This file runs before all tests to set up the testing environment
+ */
+import { jest, beforeEach, afterEach } from '@jest/globals';
+import fs from 'fs';
+import path from 'path';
+
+// Set environment to test
+process.env.NODE_ENV = 'test';
+
+// Disable debug logging during tests unless explicitly enabled
+if (!process.env.TEST_DEBUG) {
+  process.env.DEBUG = '';
+}
+
+// Prefer local binary in repository to avoid network during tests
+try {
+  const isWin = process.platform === 'win32';
+  const binDir = path.resolve(__dirname, '..', 'bin');
+  const candidate = path.join(binDir, isWin ? 'probe.exe' : 'probe-binary');
+  if (fs.existsSync(candidate)) {
+    process.env.PROBE_PATH = candidate;
+  }
+} catch {}
+
+// Global test timeout (can be overridden per test)
+jest.setTimeout(10000);
+
+// Mock console methods to avoid cluttering test output
+const originalConsole = { ...console };
+beforeEach(() => {
+  if (!process.env.TEST_VERBOSE) {
+    console.log = jest.fn();
+    console.error = jest.fn();
+    console.warn = jest.fn();
+  }
+});
+
+afterEach(() => {
+  if (!process.env.TEST_VERBOSE) {
+    console.log = originalConsole.log;
+    console.error = originalConsole.error;
+    console.warn = originalConsole.warn;
+  }
+});