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

package/data/probe/npm/jest.config.js

@@ -0,0 +1,52 @@
+/** @type {import('jest').Config} */
+export default {
+  transform: {},
+  
+  // Test environment
+  testEnvironment: 'node',
+  
+  // Test file patterns - run stable test files  
+  testMatch: [
+    '**/tests/**/*.test.js',
+    '**/src/agent/acp/tools.test.js',
+    '**/src/agent/acp/connection.test.js',
+    '**/src/agent/acp/types.test.js'
+  ],
+  
+  // Coverage configuration
+  collectCoverageFrom: [
+    'src/**/*.js',
+    '!src/**/*.test.js',
+    '!src/test-*.js',
+    '!**/node_modules/**',
+    '!**/build/**',
+    '!**/dist/**'
+  ],
+  
+  // Coverage thresholds
+  coverageThreshold: {
+    global: {
+      branches: 70,
+      functions: 70,
+      lines: 70,
+      statements: 70
+    }
+  },
+  
+  // Coverage reporters
+  coverageReporters: [
+    'text',
+    'lcov',
+    'html'
+  ],
+  
+  // Setup files
+  setupFilesAfterEnv: ['<rootDir>/tests/setup.js'],
+  
+  
+  // Verbose output
+  verbose: true,
+  
+  // Timeout for tests
+  testTimeout: 10000
+};

package/data/probe/npm/package.json

@@ -0,0 +1,117 @@
+{
+  "name": "@probelabs/probe",
+  "version": "0.6.0-rc88",
+  "description": "Node.js wrapper for the probe code search tool",
+  "main": "src/index.js",
+  "module": "src/index.js",
+  "types": "index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./src/index.js",
+      "require": "./cjs/index.cjs"
+    },
+    "./agent": {
+      "types": "./src/agent/ProbeAgent.d.ts",
+      "import": "./src/agent/ProbeAgent.js",
+      "require": "./cjs/agent/ProbeAgent.cjs"
+    },
+    "./telemetry": {
+      "import": "./src/agent/simpleTelemetry.js",
+      "require": "./cjs/agent/simpleTelemetry.cjs"
+    },
+    "./agent/mcp": {
+      "import": "./src/agent/mcp/index.js"
+    },
+    "./agent/imageConfig": {
+      "import": "./src/agent/imageConfig.js"
+    }
+  },
+  "bin": {
+    "probe": "bin/probe"
+  },
+  "files": [
+    "src/**/*",
+    "cjs/**/*",
+    "*.d.ts",
+    "src/**/*.d.ts",
+    "bin/probe",
+    "bin/probe-binary",
+    "bin/probe.exe",
+    "bin/.gitkeep",
+    "bin/binaries/*.tar.gz",
+    "bin/binaries/*.zip",
+    "scripts/postinstall.js",
+    "build/**/*",
+    "MERMAID_SUPPORT_SUMMARY.md",
+    "GITHUB_MERMAID_COMPATIBILITY.md"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "build:mcp": "node scripts/build-mcp.cjs",
+    "build:agent": "node scripts/build-agent.cjs",
+    "build:types": "echo 'TypeScript definitions already manually created'",
+    "build:cjs": "node scripts/build-cjs.js",
+    "build": "npm run build:types && npm run build:cjs && npm run build:mcp && npm run build:agent",
+    "prepack": "npm run build",
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest",
+    "test:watch": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --watch",
+    "test:coverage": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --coverage",
+    "test:verbose": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --verbose"
+  },
+  "keywords": [
+    "probe",
+    "code-search",
+    "search",
+    "ast",
+    "code-analysis",
+    "ai",
+    "llm",
+    "tools"
+  ],
+  "author": "probelabs",
+  "license": "ISC",
+  "dependencies": {
+    "@ai-sdk/amazon-bedrock": "^1.0.8",
+    "@ai-sdk/anthropic": "^2.0.8",
+    "@ai-sdk/google": "^2.0.14",
+    "@ai-sdk/openai": "^2.0.10",
+    "@anthropic-ai/claude-agent-sdk": "^0.1.46",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@probelabs/maid": "^0.0.22",
+    "adm-zip": "^0.5.16",
+    "ai": "^5.0.0",
+    "ajv": "^8.17.1",
+    "axios": "^1.8.3",
+    "dotenv": "^16.4.7",
+    "fs-extra": "^11.1.1",
+    "glob": "^10.3.10",
+    "gpt-tokenizer": "^3.0.1",
+    "tar": "^6.2.0",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.17.19",
+    "cross-env": "^7.0.3",
+    "esbuild": "^0.25.9",
+    "jest": "^29.7.0",
+    "typescript": "^5.9.2"
+  },
+  "peerDependencies": {
+    "ai": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=14.16.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/probelabs/probe.git"
+  },
+  "bugs": {
+    "url": "https://github.com/probelabs/probe/issues"
+  },
+  "homepage": "https://github.com/probelabs/probe#readme"
+}

package/data/probe/npm/scripts/build-agent.cjs

@@ -0,0 +1,75 @@
+const esbuild = require('esbuild');
+const path = require('path');
+const fs = require('fs');
+
+async function buildAgent() {
+  try {
+    console.log('Building agent...');
+    
+    // Ensure build directory exists
+    const buildDir = path.resolve(__dirname, '..', 'build', 'agent');
+    if (!fs.existsSync(buildDir)) {
+      fs.mkdirSync(buildDir, { recursive: true });
+    }
+
+    const result = await esbuild.build({
+      entryPoints: [path.resolve(__dirname, '..', 'src', 'agent', 'index.js')],
+      bundle: true,
+      outfile: path.resolve(buildDir, 'index.js'),
+      platform: 'node',
+      target: 'node18',
+      format: 'esm',
+      external: [
+        // AI SDK packages - use dynamic requires, must be external
+        '@modelcontextprotocol/sdk',
+        '@ai-sdk/anthropic',
+        '@ai-sdk/openai',
+        '@ai-sdk/google',
+        '@ai-sdk/amazon-bedrock',
+        'ai',
+        // Packages with dynamic requires
+        'fs-extra',
+        'tar',
+        'axios',
+        'dotenv',
+        // Node.js built-in modules
+        'fs',
+        'path',
+        'crypto',
+        'util',
+        'child_process',
+        'stream',
+        'events',
+        'url',
+        'os',
+        'process'
+        // Will bundle: glob, zod
+      ],
+      banner: {
+        js: '#!/usr/bin/env node'
+      },
+      minify: false, // Keep readable for debugging
+      sourcemap: false,
+      metafile: true,
+      logLevel: 'info'
+    });
+
+    // Make the output file executable
+    fs.chmodSync(path.resolve(buildDir, 'index.js'), 0o755);
+    
+    console.log('Agent build completed successfully!');
+    
+    if (result.metafile) {
+      // Optional: log build statistics
+      const analysis = await esbuild.analyzeMetafile(result.metafile);
+      console.log('Build analysis:');
+      console.log(analysis);
+    }
+    
+  } catch (error) {
+    console.error('Agent build failed:', error);
+    process.exit(1);
+  }
+}
+
+buildAgent();

package/data/probe/npm/scripts/build-cjs.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+
+import { promises as fs } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import esbuild from 'esbuild';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const npmDir = join(__dirname, '..');
+const cjsDir = join(npmDir, 'cjs');
+
+// Clean CJS directory
+try {
+  await fs.rm(cjsDir, { recursive: true, force: true });
+} catch (err) {
+  // Directory might not exist
+}
+
+// Create CJS directory structure
+await fs.mkdir(cjsDir, { recursive: true });
+await fs.mkdir(join(cjsDir, 'agent'), { recursive: true });
+
+console.log('Building CommonJS modules...');
+
+// Build main index file
+await esbuild.build({
+  entryPoints: [join(npmDir, 'src/index.js')],
+  bundle: true,
+  platform: 'node',
+  format: 'cjs',
+  outfile: join(cjsDir, 'index.cjs'),
+  external: [
+    '@ai-sdk/anthropic',
+    '@ai-sdk/openai', 
+    '@ai-sdk/google',
+    '@modelcontextprotocol/sdk',
+    '@opentelemetry/*',
+    'ai',
+    'axios',
+    'fs-extra',
+    'tar',
+    'crypto',
+    'fs',
+    'path',
+    'events',
+    'child_process',
+    'stream',
+    'util',
+    'os'
+  ],
+  define: {
+    'import.meta.url': '"file:///"'
+  }
+});
+
+// Build ProbeAgent separately
+await esbuild.build({
+  entryPoints: [join(npmDir, 'src/agent/ProbeAgent.js')],
+  bundle: true,
+  platform: 'node',
+  format: 'cjs',
+  outfile: join(cjsDir, 'agent/ProbeAgent.cjs'),
+  external: [
+    '@ai-sdk/anthropic',
+    '@ai-sdk/openai',
+    '@ai-sdk/google',
+    '@modelcontextprotocol/sdk',
+    '@opentelemetry/*',
+    'ai',
+    'axios',
+    'fs-extra',
+    'tar',
+    'crypto',
+    'fs',
+    'path',
+    'events',
+    'child_process',
+    'stream',
+    'util',
+    'os'
+  ],
+  define: {
+    'import.meta.url': '"file:///"'
+  }
+});
+
+// Build simpleTelemetry module
+await esbuild.build({
+  entryPoints: [join(npmDir, 'src/agent/simpleTelemetry.js')],
+  bundle: true,
+  platform: 'node',
+  format: 'cjs',
+  outfile: join(cjsDir, 'agent/simpleTelemetry.cjs'),
+  external: [
+    '@opentelemetry/*',
+    'crypto',
+    'fs',
+    'path',
+    'os'
+  ],
+  define: {
+    'import.meta.url': '"file:///"'
+  }
+});
+
+// Note: telemetry.js removed - using simpleTelemetry.js instead
+
+// Create package.json for CJS directory
+const cjsPackageJson = {
+  type: 'commonjs'
+};
+
+await fs.writeFile(
+  join(cjsDir, 'package.json'),
+  JSON.stringify(cjsPackageJson, null, 2)
+);
+
+console.log('✅ CommonJS build completed');
+console.log(`   📁 Built to: ${cjsDir}`);
+console.log('   📦 Main: cjs/index.cjs');
+console.log('   🤖 Agent: cjs/agent/ProbeAgent.cjs');
+console.log('   📊 Simple Telemetry: cjs/agent/simpleTelemetry.cjs');
+console.log('   📈 Full Telemetry: cjs/agent/telemetry.cjs');

package/data/probe/npm/scripts/build-mcp.cjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+const { execSync } = require('child_process');
+
+async function buildMcp() {
+  try {
+    console.log('Building MCP TypeScript...');
+    
+    // Ensure build directory exists
+    await fs.ensureDir('build');
+    
+    // Copy src files to build directory
+    console.log('Copying source files...');
+    await fs.copy('src', 'build', { 
+      overwrite: true,
+      errorOnExist: false 
+    });
+    
+    // Run TypeScript compiler
+    console.log('Compiling TypeScript...');
+    execSync('tsc src/mcp/index.ts --outDir build/mcp --module esnext --target es2020 --moduleResolution node --esModuleInterop --allowSyntheticDefaultImports --skipLibCheck', {
+      stdio: 'inherit',
+      cwd: process.cwd()
+    });
+    
+    console.log('✅ MCP build completed successfully');
+    
+  } catch (error) {
+    console.error('❌ MCP build failed:', error.message);
+    process.exit(1);
+  }
+}
+
+buildMcp();

package/data/probe/npm/scripts/postinstall.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+
+/**
+ * Post-install script for the probe package
+ * 
+ * This script is executed after the package is installed.
+ * It downloads the probe binary and replaces the placeholder binary with the actual one.
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { extractBundledBinary } from '../src/extractor.js';
+import { downloadProbeBinary } from '../src/downloader.js';
+
+const execFileAsync = promisify(execFile);
+
+// Get the directory of the current module
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Path to the bin directory (relative to this script)
+const binDir = path.resolve(__dirname, '..', 'bin');
+
+/**
+ * Main function
+ */
+async function main() {
+	try {
+		// Skip postinstall in CI environments to prevent wrong binaries from being packaged
+		const isCI = process.env.CI || process.env.GITHUB_ACTIONS || process.env.CONTINUOUS_INTEGRATION || 
+		             process.env.BUILD_NUMBER || process.env.JENKINS_URL || process.env.TRAVIS ||
+		             process.env.CIRCLECI || process.env.GITLAB_CI;
+		
+		if (isCI) {
+			if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+				console.log('Detected CI environment, skipping probe binary download');
+			}
+			return;
+		}
+
+		// Skip postinstall if binary already exists (for development)
+		const isWindows = process.platform === 'win32';
+		const targetBinaryName = isWindows ? 'probe.exe' : 'probe-binary';
+		const targetBinaryPath = path.join(binDir, targetBinaryName);
+		
+		if (await fs.pathExists(targetBinaryPath)) {
+			if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+				console.log(`Probe binary already exists at ${targetBinaryPath}, skipping download`);
+			}
+			return;
+		}
+
+		// Create the bin directory if it doesn't exist
+		if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+			console.log(`Creating bin directory at: ${binDir}`);
+		}
+		await fs.ensureDir(binDir);
+		if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+			console.log('Bin directory created successfully');
+		}
+
+		// Create a README file in the bin directory
+		const readmePath = path.join(binDir, 'README.md');
+		const readmeContent = `# Probe Binary Directory
+
+This directory is used to store the downloaded probe binary.
+
+The binary is automatically downloaded during package installation.
+If you encounter any issues with the download, you can manually place the probe binary in this directory.
+
+Binary name should be:
+- \`probe\` (on Linux/macOS)
+- \`probe.exe\` (on Windows)
+
+You can download the binary from: https://github.com/probelabs/probe/releases
+`;
+
+		await fs.writeFile(readmePath, readmeContent);
+		if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+			console.log('Created README file in bin directory');
+		}
+
+		// Create a .gitignore file to ignore binaries but keep the directory
+		const gitignorePath = path.join(binDir, '.gitignore');
+		const gitignoreContent = `# Ignore all files in this directory
+*
+# Except these files
+!.gitignore
+!.gitkeep
+!README.md
+!probe
+`;
+
+		await fs.writeFile(gitignorePath, gitignoreContent);
+		if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+			console.log('Created .gitignore file in bin directory');
+		}
+
+		// Get the package version first
+		let packageVersion = '0.0.0';
+		const possiblePaths = [
+			path.resolve(__dirname, '..', 'package.json'),      // When installed from npm: scripts/../package.json
+			path.resolve(__dirname, '..', '..', 'package.json') // In development: scripts/../../package.json
+		];
+
+		for (const packageJsonPath of possiblePaths) {
+			try {
+				if (fs.existsSync(packageJsonPath)) {
+					if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+						console.log(`Found package.json at: ${packageJsonPath}`);
+					}
+					const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+					if (packageJson.version) {
+						packageVersion = packageJson.version;
+						if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+							console.log(`Using version from package.json: ${packageVersion}`);
+						}
+						break;
+					}
+				}
+			} catch (err) {
+				console.error(`Error reading package.json at ${packageJsonPath}:`, err);
+			}
+		}
+
+		// Try to extract bundled binary first
+		let binaryPath;
+		try {
+			if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+				console.log('Extracting bundled probe binary...');
+			}
+			binaryPath = await extractBundledBinary(packageVersion);
+			if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+				console.log(`Successfully extracted bundled binary to: ${binaryPath}`);
+			}
+		} catch (extractError) {
+			// If bundled binary extraction fails, fall back to downloading
+			if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+				console.log(`Bundled binary extraction failed: ${extractError.message}`);
+				console.log('Falling back to downloading binary from GitHub...');
+			} else {
+				console.log('Bundled binary not found, downloading from GitHub...');
+			}
+
+			try {
+				binaryPath = await downloadProbeBinary(packageVersion);
+				if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+					console.log(`Successfully downloaded probe binary to: ${binaryPath}`);
+				}
+			} catch (downloadError) {
+				throw new Error(
+					`Failed to install probe binary.\n` +
+					`Bundled extraction error: ${extractError.message}\n` +
+					`Download error: ${downloadError.message}\n` +
+					`\n` +
+					`Please check:\n` +
+					`1. Your platform is supported\n` +
+					`2. You have internet connectivity\n` +
+					`3. GitHub releases are accessible`
+				);
+			}
+		}
+
+		// Copy the extracted/downloaded binary to the correct location if needed
+		// (targetBinaryName and targetBinaryPath already declared at the beginning of main function)
+			if (binaryPath !== targetBinaryPath) {
+				if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+					console.log(`Copying binary to ${targetBinaryPath} from ${binaryPath}`);
+				}
+				await fs.copyFile(binaryPath, targetBinaryPath);
+				await fs.chmod(targetBinaryPath, 0o755); // Make it executable
+			}
+
+			// On macOS, try to remove quarantine attributes that might prevent execution
+			if (process.platform === 'darwin') {
+				try {
+					// Security: Use execFile with array args instead of exec to prevent command injection
+					// Validate that the path is within the bin directory
+					const normalizedPath = path.normalize(targetBinaryPath);
+					const normalizedBinDir = path.normalize(binDir);
+					if (!normalizedPath.startsWith(normalizedBinDir)) {
+						throw new Error('Invalid binary path - outside of bin directory');
+					}
+
+					await execFileAsync('xattr', ['-d', 'com.apple.quarantine', normalizedPath]).catch(() => {
+						// Ignore errors - xattr may not exist or file may not have quarantine attribute
+					});
+
+					if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+						console.log('Removed quarantine attributes from binary');
+					}
+				} catch (error) {
+					// Ignore errors - this is just a precaution
+					if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+						console.log('Note: Could not remove quarantine attributes (this is usually fine)');
+					}
+				}
+			}
+
+		if (process.env.DEBUG === '1' || process.env.VERBOSE === '1') {
+			console.log('\nProbe binary was successfully installed.');
+			console.log('You can now use the probe command directly from the command line.');
+		}
+	} catch (error) {
+		console.error(`Error in postinstall script: ${error.message}`);
+		console.error('You may need to manually create the bin directory or run with elevated privileges.');
+	}
+}
+
+// Execute the main function
+main().catch(error => {
+	console.error('Unexpected error during postinstall:', error);
+});

package/data/probe/npm/test-codex-e2e.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+/**
+ * End-to-end test for Codex integration
+ * Run with: node test-codex-e2e.js
+ */
+
+import { ProbeAgent } from './src/agent/ProbeAgent.js';
+
+console.log('🧪 Codex Integration E2E Test\n');
+console.log('Testing basic query with Codex engine...\n');
+
+async function main() {
+  let agent;
+
+  try {
+    // Create agent with Codex provider (use default model, not gpt-4o)
+    console.log('1️⃣  Creating ProbeAgent with provider: codex (using default model)');
+    agent = new ProbeAgent({
+      provider: 'codex',
+      model: null,  // Don't specify model, let Codex use its default
+      allowedFolders: [process.cwd()],
+      debug: true
+    });
+
+    console.log('\n2️⃣  Initializing agent...');
+    await agent.initialize();
+
+    console.log('\n✅ Agent initialized successfully!');
+    console.log(`   Provider: ${agent.clientApiProvider}`);
+    console.log(`   API Type: ${agent.apiType}`);
+    console.log(`   Model: ${agent.model}`);
+
+    // Test simple query
+    console.log('\n3️⃣  Testing simple query: "What is 2 + 2?"');
+    console.log('   (This should trigger Codex CLI)\n');
+
+    const response = await agent.answer('What is 2 + 2?');
+
+    console.log('\n✅ Query completed!');
+    console.log('\n📝 Response:');
+    console.log('─'.repeat(60));
+    console.log(response);
+    console.log('─'.repeat(60));
+
+    // Clean up
+    console.log('\n4️⃣  Cleaning up...');
+    if (agent.engine && agent.engine.close) {
+      await agent.engine.close();
+    }
+
+    console.log('\n✅ All tests passed! 🎉\n');
+    process.exit(0);
+
+  } catch (error) {
+    console.error('\n❌ Test failed:', error.message);
+    console.error('\nStack trace:');
+    console.error(error.stack);
+
+    // Clean up on error
+    if (agent?.engine?.close) {
+      try {
+        await agent.engine.close();
+      } catch (cleanupError) {
+        // Ignore cleanup errors
+      }
+    }
+
+    console.log('\n💡 Common issues:');
+    console.log('   - Make sure Codex CLI is installed: https://openai.com/codex');
+    console.log('   - Check that you can run: codex --version');
+    console.log('   - Ensure you have an active Codex session');
+
+    process.exit(1);
+  }
+}
+
+main();