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

package/data/probe/npm/example-usage.js

@@ -0,0 +1,335 @@
+// Example of using the probe npm package in Node.js
+
+import { search, query, extract, tools } from '@probelabs/probe';
+
+// Basic search example
+async function basicSearchExample() {
+	console.log('=== Basic Search Example ===');
+
+	try {
+		const results = await search({
+			path: '/path/to/your/project',
+			query: 'function',
+			maxResults: 5
+		});
+
+		console.log('Search results:');
+		console.log(results);
+	} catch (error) {
+		console.error('Search error:', error);
+	}
+}
+
+// Advanced search with multiple options
+async function advancedSearchExample() {
+	console.log('\n=== Advanced Search Example ===');
+
+	try {
+		const results = await search({
+			path: '/path/to/your/project',
+			query: 'config AND (parse OR tokenize)',
+			ignore: ['node_modules', 'dist'],
+			reranker: 'hybrid',
+			frequencySearch: true,
+			maxResults: 10,
+			maxTokens: 20000,
+			allowTests: false
+		});
+
+		console.log('Advanced search results:');
+		console.log(results);
+	} catch (error) {
+		console.error('Advanced search error:', error);
+	}
+}
+
+// Query for specific code structures
+async function queryExample() {
+	console.log('\n=== Query Example ===');
+
+	try {
+		// Find all JavaScript functions
+		const jsResults = await query({
+			path: '/path/to/your/project',
+			pattern: 'function $NAME($$$PARAMS) $$$BODY',
+			language: 'javascript',
+			maxResults: 5
+		});
+
+		console.log('JavaScript functions:');
+		console.log(jsResults);
+
+		// Find all Rust structs
+		const rustResults = await query({
+			path: '/path/to/your/project',
+			pattern: 'struct $NAME $$$BODY',
+			language: 'rust',
+			maxResults: 5
+		});
+
+		console.log('Rust structs:');
+		console.log(rustResults);
+	} catch (error) {
+		console.error('Query error:', error);
+	}
+}
+
+// Extract code blocks from specific files
+async function extractExample() {
+	console.log('\n=== Extract Example ===');
+
+	try {
+		const results = await extract({
+			files: [
+				'/path/to/your/project/src/main.js',
+				'/path/to/your/project/src/utils.js:42'  // Extract from line 42
+			],
+			contextLines: 2,
+			format: 'markdown'
+		});
+
+		console.log('Extracted code:');
+		console.log(results);
+	} catch (error) {
+		console.error('Extract error:', error);
+	}
+}
+
+// Practical example: Find and analyze all API endpoints
+async function findApiEndpoints() {
+	console.log('\n=== Find API Endpoints Example ===');
+
+	try {
+		// Search for route definitions in Express.js
+		const expressRoutes = await search({
+			path: '/path/to/your/project',
+			query: 'app.get OR app.post OR app.put OR app.delete',
+			maxResults: 20
+		});
+
+		console.log('Express.js routes:');
+		console.log(expressRoutes);
+
+		// Search for controller methods in a Spring Boot application
+		const springControllers = await query({
+			path: '/path/to/your/project',
+			pattern: '@RequestMapping($$$PARAMS) $$$BODY',
+			language: 'java',
+			maxResults: 20
+		});
+
+		console.log('Spring Boot controllers:');
+		console.log(springControllers);
+	} catch (error) {
+		console.error('API endpoint search error:', error);
+	}
+}
+
+// Practical example: Generate documentation from code comments
+async function generateDocumentation() {
+	console.log('\n=== Generate Documentation Example ===');
+
+	try {
+		// Search for JSDoc comments
+		const jsdocComments = await search({
+			path: '/path/to/your/project',
+			query: '/**',
+			maxResults: 50
+		});
+
+		console.log('JSDoc comments:');
+		console.log(jsdocComments);
+
+		// Process the comments to generate documentation
+		const docs = processJsDocComments(jsdocComments);
+		console.log('Generated documentation:', docs);
+	} catch (error) {
+		console.error('Documentation generation error:', error);
+	}
+}
+
+// Helper function for the documentation example
+function processJsDocComments(comments) {
+	// This would parse the JSDoc comments and convert them to documentation
+	return "Documentation would be generated here";
+}
+
+// Practical example: Find unused code
+async function findUnusedCode() {
+	console.log('\n=== Find Unused Code Example ===');
+
+	try {
+		// First, find all function definitions
+		const functionDefs = await query({
+			path: '/path/to/your/project',
+			pattern: 'function $NAME($$$PARAMS) $$$BODY',
+			language: 'javascript',
+			maxResults: 100
+		});
+
+		// Extract function names
+		const functionNames = extractFunctionNames(functionDefs);
+
+		// For each function, search for its usage
+		const unusedFunctions = [];
+
+		for (const name of functionNames) {
+			const usages = await search({
+				path: '/path/to/your/project',
+				query: name,
+				maxResults: 2  // We only need to know if it's used at least once
+			});
+
+			// If only one result (the definition itself), it's unused
+			if (countOccurrences(usages) <= 1) {
+				unusedFunctions.push(name);
+			}
+		}
+
+		console.log('Potentially unused functions:');
+		console.log(unusedFunctions);
+	} catch (error) {
+		console.error('Unused code search error:', error);
+	}
+}
+
+// Helper functions for the unused code example
+function extractFunctionNames(functionDefs) {
+	// This would extract function names from the query results
+	return ["someFunction", "anotherFunction"];
+}
+
+function countOccurrences(searchResults) {
+	// This would count occurrences in the search results
+	return 1;
+}
+
+// Example of using AI tools with Vercel AI SDK
+async function vercelAiToolsExample() {
+	console.log('\n=== Vercel AI SDK Tools Example ===');
+
+	try {
+		// Import necessary modules (in a real application)
+		// import { generateText } from 'ai';
+		// import { createOpenAI } from '@ai-sdk/openai';
+
+		console.log('Using Vercel AI SDK tools:');
+		console.log('- searchTool:', typeof tools.searchTool);
+		console.log('- queryTool:', typeof tools.queryTool);
+		console.log('- extractTool:', typeof tools.extractTool);
+
+		// Example of how to use the tools with Vercel AI SDK
+		console.log('\nExample usage with Vercel AI SDK:');
+		console.log(`
+async function chatWithAI(userMessage) {
+  const result = await generateText({
+    model: provider(modelName),
+    messages: [{ role: 'user', content: userMessage }],
+    system: "You are a code intelligence assistant. Use the provided tools to search and analyze code.",
+    tools: {
+      search: tools.searchTool,
+      query: tools.queryTool,
+      extract: tools.extractTool
+    },
+    maxSteps: 15,
+    temperature: 0.7
+  });
+  
+  return result.text;
+}`);
+	} catch (error) {
+		console.error('Vercel AI SDK tools error:', error);
+	}
+}
+
+// Example of using AI tools with LangChain
+async function langchainToolsExample() {
+	console.log('\n=== LangChain Tools Example ===');
+
+	try {
+		// Create the LangChain tools
+		const searchTool = tools.createSearchTool();
+		const queryTool = tools.createQueryTool();
+		const extractTool = tools.createExtractTool();
+
+		console.log('Created LangChain tools:');
+		console.log('- searchTool:', typeof searchTool);
+		console.log('- queryTool:', typeof queryTool);
+		console.log('- extractTool:', typeof extractTool);
+
+		// Example of how to use the tools with LangChain
+		console.log('\nExample usage with LangChain:');
+		console.log(`
+async function chatWithAI(userMessage) {
+  const model = new ChatOpenAI({
+    modelName: "gpt-4o",
+    temperature: 0.7
+  }).withTools([searchTool, queryTool, extractTool]);
+  
+  const result = await model.invoke([
+    { role: "system", content: "You are a code intelligence assistant. Use the provided tools to search and analyze code." },
+    { role: "user", content: userMessage }
+  ]);
+  
+  return result.content;
+}`);
+	} catch (error) {
+		console.error('LangChain tools error:', error);
+	}
+}
+
+// Example of using the DEFAULT_SYSTEM_MESSAGE
+async function systemMessageExample() {
+	console.log('\n=== System Message Example ===');
+
+	try {
+		console.log('DEFAULT_SYSTEM_MESSAGE:', typeof tools.DEFAULT_SYSTEM_MESSAGE);
+
+		// Example of how to use the DEFAULT_SYSTEM_MESSAGE
+		console.log('\nExample usage of DEFAULT_SYSTEM_MESSAGE:');
+		console.log(`
+// Use the default system message in your AI application
+const systemMessage = tools.DEFAULT_SYSTEM_MESSAGE;
+
+// Example with Vercel AI SDK
+const result = await generateText({
+  model: provider(modelName),
+  messages: [{ role: 'user', content: userMessage }],
+  system: tools.DEFAULT_SYSTEM_MESSAGE,
+  tools: {
+    search: tools.searchTool,
+    query: tools.queryTool,
+    extract: tools.extractTool
+  }
+});
+
+// Example with LangChain
+const model = new ChatOpenAI({
+  modelName: "gpt-4o",
+  temperature: 0.7
+}).withTools([searchTool, queryTool, extractTool]);
+
+const result = await model.invoke([
+  { role: "system", content: tools.DEFAULT_SYSTEM_MESSAGE },
+  { role: "user", content: userMessage }
+]);`);
+	} catch (error) {
+		console.error('System message error:', error);
+	}
+}
+
+// Run all examples
+async function runAllExamples() {
+	await basicSearchExample();
+	await advancedSearchExample();
+	await queryExample();
+	await extractExample();
+	await findApiEndpoints();
+	await generateDocumentation();
+	await findUnusedCode();
+	await vercelAiToolsExample();
+	await langchainToolsExample();
+	await systemMessageExample();
+}
+
+runAllExamples().catch(console.error);

package/data/probe/npm/examples/multi-engine-demo.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+
+/**
+ * Demonstration of ProbeAgent with Claude Code integration
+ * Shows auto-fallback and provider selection
+ */
+
+import { ProbeAgent } from '../src/agent/ProbeAgent.js';
+import chalk from 'chalk';
+
+console.log(chalk.blue('=' .repeat(70)));
+console.log(chalk.blue('  CLAUDE CODE INTEGRATION DEMONSTRATION'));
+console.log(chalk.blue('=' .repeat(70) + '\n'));
+
+// Custom persona for code review
+const codeReviewerPersona = `You are an expert code reviewer specializing in JavaScript/TypeScript.
+Your role is to:
+- Analyze code quality and patterns
+- Identify potential bugs or issues
+- Suggest improvements
+- Focus on best practices and maintainability`;
+
+async function demonstrateProvider(providerName, persona, question) {
+  console.log(chalk.cyan(`\n🔧 Testing ${providerName || 'Auto-Detect'} Provider\n`));
+  console.log(chalk.gray('─'.repeat(60)));
+
+  try {
+    const agentOptions = {
+      customPrompt: persona,
+      maxIterations: 3,
+      debug: false
+    };
+
+    if (providerName) {
+      agentOptions.provider = providerName;
+    }
+
+    const agent = new ProbeAgent(agentOptions);
+
+    await agent.initialize();
+
+    console.log(chalk.green(`✅ Initialized (provider: ${agent.clientApiProvider || 'auto'})`));
+
+    let toolCalls = [];
+    if (agent.events) {
+      agent.events.on('toolCall', (event) => {
+        if (event.status === 'started') {
+          console.log(chalk.yellow(`   Tool: ${event.name}`));
+          toolCalls.push(event.name);
+        }
+      });
+    }
+
+    console.log(chalk.magenta(`\n❓ Question: ${question}`));
+    const startTime = Date.now();
+    const response = await agent.answer(question);
+    const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+
+    console.log(chalk.green(`\n✅ Response received (${duration}s)`));
+    console.log(chalk.white(response.substring(0, 300) + '...'));
+
+    if (toolCalls.length > 0) {
+      console.log(chalk.cyan(`\n📊 Tools used: ${toolCalls.join(', ')}`));
+    }
+
+  } catch (error) {
+    console.error(chalk.red(`❌ Error: ${error.message}`));
+  }
+}
+
+async function main() {
+  console.log(chalk.yellow('This demo shows Claude Code integration features:\n'));
+  console.log(chalk.gray('  • Auto-fallback when no API keys present'));
+  console.log(chalk.gray('  • Explicit provider selection'));
+  console.log(chalk.gray('  • Custom personas and system prompts'));
+  console.log(chalk.gray('  • Tool event extraction\n'));
+
+  // Demo 1: Auto-detect (will use Claude Code if no API keys)
+  console.log(chalk.blue('\n1️⃣ AUTO-DETECT MODE'));
+  console.log(chalk.gray('─'.repeat(60)));
+  await demonstrateProvider(
+    null,  // Auto-detect
+    codeReviewerPersona,
+    'Find error handling patterns in this codebase'
+  );
+
+  // Demo 2: Explicit Claude Code
+  console.log(chalk.blue('\n\n2️⃣ EXPLICIT CLAUDE CODE PROVIDER'));
+  console.log(chalk.gray('─'.repeat(60)));
+  await demonstrateProvider(
+    'claude-code',
+    codeReviewerPersona,
+    'Analyze the ProbeAgent class structure'
+  );
+
+  console.log(chalk.blue('\n\n' + '=' .repeat(70)));
+  console.log(chalk.green('✨ Demonstration Complete!\n'));
+
+  console.log(chalk.cyan('Key Features:'));
+  console.log(chalk.gray('  • Single "provider" parameter for all engines'));
+  console.log(chalk.gray('  • Auto-detection when provider not specified'));
+  console.log(chalk.gray('  • Custom system prompts and personas'));
+  console.log(chalk.gray('  • Seamless tool integration'));
+
+  console.log(chalk.cyan('\nUsage Examples:'));
+  console.log(chalk.gray('  # Auto-detect (uses API keys or claude command)'));
+  console.log(chalk.gray('  const agent = new ProbeAgent({ allowedFolders: ["/path"] })'));
+  console.log(chalk.gray('\n  # Explicit Claude Code'));
+  console.log(chalk.gray('  const agent = new ProbeAgent({ provider: "claude-code" })'));
+  console.log(chalk.gray('\n  # CLI usage'));
+  console.log(chalk.gray('  node probe-agent-cli.js --provider claude-code "your question"\n'));
+}
+
+main().catch(error => {
+  console.error(chalk.red('Fatal error:'), error);
+  process.exit(1);
+});

package/data/probe/npm/examples/probe-agent-cli.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+
+/**
+ * CLI for testing ProbeAgent with different providers
+ * Usage: node probe-agent-cli.js [--provider vercel|claude-code] "your question"
+ */
+
+import { ProbeAgent } from '../src/agent/ProbeAgent.js';
+import chalk from 'chalk';
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+// Detect provider from environment (claude-code auto-detects if no API keys)
+let provider = process.env.USE_CLAUDE_CODE === 'true' ? 'claude-code' : null;
+let question = '';
+
+// Parse --provider flag (overrides environment)
+if (args[0] === '--provider' && args[1]) {
+  provider = args[1];
+  question = args.slice(2).join(' ');
+} else {
+  question = args.join(' ');
+}
+
+// Default question if none provided
+if (!question) {
+  question = "Find all async functions in this codebase that handle errors";
+}
+
+// Color configuration
+const colors = {
+  provider: chalk.cyan,
+  tool: chalk.yellow,
+  result: chalk.green,
+  error: chalk.red,
+  debug: chalk.gray,
+  prompt: chalk.magenta,
+  text: chalk.white
+};
+
+const displayProvider = provider || 'auto-detect';
+console.log(colors.provider(`\n🚀 Starting Probe Agent (provider: ${displayProvider})\n`));
+console.log(colors.prompt(`Question: "${question}"\n`));
+
+// Check for API key (not required for Claude Code)
+if (provider === 'claude-code') {
+  console.log(colors.debug('Using Claude Code provider (requires claude command installed)'));
+} else if (!provider && !process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY) {
+  console.log(colors.debug('No API keys found - will attempt Claude Code auto-fallback'));
+}
+
+async function runAgent(providerName) {
+  const startTime = Date.now();
+
+  try {
+    // Create agent - provider is optional (auto-detects)
+    const agentOptions = {
+      debug: true,
+      allowedFolders: [process.cwd()],
+      maxIterations: 5
+    };
+
+    // Set provider if specified (otherwise auto-detect)
+    if (providerName) {
+      agentOptions.provider = providerName;
+    }
+
+    const agent = new ProbeAgent(agentOptions);
+
+    console.log(colors.text('\n📊 Initializing agent...\n'));
+    
+    await agent.initialize();
+
+    // Track tool calls
+    let toolCallCount = 0;
+    if (agent.events) {
+      agent.events.on('toolCall', (event) => {
+        toolCallCount++;
+        if (event.status === 'started') {
+          console.log(colors.tool(`\n🔧 Tool ${toolCallCount}: ${event.name}`));
+          if (event.args && Object.keys(event.args).length > 0) {
+            console.log(colors.debug(`   Args: ${JSON.stringify(event.args, null, 2).substring(0, 200)}...`));
+          }
+        }
+      });
+    }
+
+    console.log(colors.text('🤔 Querying agent...\n'));
+
+    const response = await agent.answer(question);
+
+    console.log(colors.result('\n✅ Response:\n'));
+    console.log(colors.text(response));
+    console.log(colors.text('\n' + '─'.repeat(80)));
+
+    const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+    console.log(colors.debug(`\n⏱️  Duration: ${duration}s`));
+    console.log(colors.debug(`🔧 Tools used: ${toolCallCount}`));
+    console.log(colors.provider(`🚀 Provider: ${agent.clientApiProvider || 'auto-detected'}\n`));
+
+  } catch (error) {
+    console.error(colors.error('\n❌ Error:'), error.message);
+    if (error.stack) {
+      console.error(colors.debug(error.stack));
+    }
+    process.exit(1);
+  }
+}
+
+runAgent(provider).catch(error => {
+  console.error(colors.error('Fatal error:'), error);
+  process.exit(1);
+});

package/data/probe/npm/examples/test-agent-edit.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+/**
+ * Test script to verify edit and create tools are available with --allow-edit flag
+ */
+
+import { ProbeAgent } from '../src/agent/ProbeAgent.js';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { promises as fs } from 'fs';
+import { existsSync } from 'fs';
+
+async function testAgentWithEdit() {
+  const testDir = join(tmpdir(), 'probe-agent-edit-test');
+  await fs.mkdir(testDir, { recursive: true });
+
+  console.log('Testing ProbeAgent with edit tools...\n');
+  console.log(`Test directory: ${testDir}\n`);
+
+  try {
+    // Test 1: Without --allow-edit flag
+    console.log('1. Testing WITHOUT --allow-edit flag:');
+    const agentWithoutEdit = new ProbeAgent({
+      path: testDir,
+      allowedFolders: [testDir],
+      allowEdit: false, // Explicitly disabled
+      verbose: true
+    });
+
+    const tools1 = agentWithoutEdit.getTools();
+    console.log('Available tools without --allow-edit:', Object.keys(tools1));
+    console.log('Has editTool?', 'editTool' in tools1);
+    console.log('Has createTool?', 'createTool' in tools1);
+    console.log();
+
+    // Test 2: With --allow-edit flag
+    console.log('2. Testing WITH --allow-edit flag:');
+    const agentWithEdit = new ProbeAgent({
+      path: testDir,
+      allowedFolders: [testDir],
+      allowEdit: true, // Enabled
+      verbose: true
+    });
+
+    const tools2 = agentWithEdit.getTools();
+    console.log('Available tools with --allow-edit:', Object.keys(tools2));
+    console.log('Has editTool?', 'editTool' in tools2);
+    console.log('Has createTool?', 'createTool' in tools2);
+    console.log();
+
+    // Test 3: Actually use the tools if available
+    if (tools2.editTool && tools2.createTool) {
+      console.log('3. Testing actual tool usage through agent:');
+
+      // Create a file
+      console.log('Creating test.txt...');
+      const createResult = await tools2.createTool.execute({
+        file_path: join(testDir, 'test.txt'),
+        content: 'Hello from ProbeAgent!'
+      });
+      console.log('Create success:', createResult.success);
+
+      // Edit the file
+      console.log('Editing test.txt...');
+      const editResult = await tools2.editTool.execute({
+        file_path: join(testDir, 'test.txt'),
+        old_string: 'Hello from ProbeAgent!',
+        new_string: 'Hello from ProbeAgent with Edit tools!'
+      });
+      console.log('Edit success:', editResult.success);
+
+      // Verify the content
+      const content = await fs.readFile(join(testDir, 'test.txt'), 'utf-8');
+      console.log('Final content:', content);
+      console.log();
+    }
+
+    // Test 4: Test tool definitions
+    console.log('4. Testing tool definitions:');
+    const toolDefinitions = agentWithEdit.getToolDefinitions();
+    console.log('Available tool definitions:', toolDefinitions.length);
+    const hasEditDef = toolDefinitions.some(def => def.includes('## edit'));
+    const hasCreateDef = toolDefinitions.some(def => def.includes('## create'));
+    console.log('Has edit definition?', hasEditDef);
+    console.log('Has create definition?', hasCreateDef);
+    console.log();
+
+    // Test 5: Test with a simple prompt
+    console.log('5. Testing with a simple prompt (this would normally call the AI):');
+    console.log('Agent is configured with:');
+    console.log('- allowEdit:', agentWithEdit.config.allowEdit);
+    console.log('- allowedFolders:', agentWithEdit.config.allowedFolders);
+    console.log('- Available tools:', Object.keys(agentWithEdit.getTools()));
+    console.log();
+
+    // Clean up
+    console.log('Cleaning up...');
+    await fs.rm(testDir, { recursive: true, force: true });
+    console.log('\n✅ All tests completed successfully!');
+    console.log('\nSummary:');
+    console.log('- Edit and Create tools are NOT available without --allow-edit flag');
+    console.log('- Edit and Create tools ARE available with --allow-edit flag');
+    console.log('- Tools can be executed successfully when enabled');
+
+  } catch (error) {
+    console.error('Test failed:', error);
+    // Clean up on error
+    await fs.rm(testDir, { recursive: true, force: true }).catch(() => {});
+    process.exit(1);
+  }
+}
+
+// Run the test
+testAgentWithEdit().catch(console.error);