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

package/data/probe/examples/chat/mcpServer.js

@@ -0,0 +1,341 @@
+/**
+ * MCP Server implementation for Probe Agent
+ * Provides MCP tools that integrate with the Probe code search capabilities
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  searchToolInstance,
+  queryToolInstance,
+  extractToolInstance,
+  listFilesToolInstance,
+  searchFilesToolInstance
+} from './probeTool.js';
+import { ProbeChat } from './probeChat.js';
+
+/**
+ * Create MCP server for Probe tools
+ */
+export async function createMCPServer(options = {}) {
+  const server = new Server(
+    {
+      name: 'probe-mcp-server',
+      version: '1.0.0',
+    },
+    {
+      capabilities: {
+        tools: {},
+      },
+    }
+  );
+
+  // List available tools
+  server.setRequestHandler('tools/list', async () => ({
+    tools: [
+      {
+        name: 'probe_search',
+        description: 'Search code using keywords or patterns with flexible text search',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            query: {
+              type: 'string',
+              description: 'Search query using elastic search syntax'
+            },
+            path: {
+              type: 'string',
+              description: 'Directory to search in (defaults to current working directory)'
+            },
+            maxTokens: {
+              type: 'number',
+              description: 'Maximum tokens to return (default: 10000)'
+            },
+            allowTests: {
+              type: 'boolean',
+              description: 'Include test files in results (default: false)'
+            },
+            exact: {
+              type: 'boolean',
+              description: 'Perform exact search without tokenization'
+            },
+            language: {
+              type: 'string',
+              description: 'Limit search to specific programming language'
+            }
+          },
+          required: ['query']
+        }
+      },
+      {
+        name: 'probe_query',
+        description: 'Query code using structural AST patterns',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            pattern: {
+              type: 'string',
+              description: 'AST pattern to search for'
+            },
+            path: {
+              type: 'string',
+              description: 'Directory to search in'
+            },
+            language: {
+              type: 'string',
+              description: 'Programming language'
+            },
+            allowTests: {
+              type: 'boolean',
+              description: 'Include test files'
+            }
+          },
+          required: ['pattern']
+        }
+      },
+      {
+        name: 'probe_extract',
+        description: 'Extract code blocks from files',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            targets: {
+              type: 'array',
+              items: { type: 'string' },
+              description: 'File paths or file:line specifications to extract'
+            },
+            contextLines: {
+              type: 'number',
+              description: 'Number of context lines'
+            },
+            allowTests: {
+              type: 'boolean',
+              description: 'Allow test files'
+            },
+            format: {
+              type: 'string',
+              enum: ['plain', 'markdown', 'json'],
+              description: 'Output format'
+            }
+          },
+          required: ['targets']
+        }
+      },
+      {
+        name: 'probe_list_files',
+        description: 'List files in a directory',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            directory: {
+              type: 'string',
+              description: 'Directory path to list files from'
+            }
+          }
+        }
+      },
+      {
+        name: 'probe_search_files',
+        description: 'Search for files using glob patterns',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            pattern: {
+              type: 'string',
+              description: 'Glob pattern to match files'
+            },
+            directory: {
+              type: 'string',
+              description: 'Directory to search in'
+            },
+            recursive: {
+              type: 'boolean',
+              description: 'Search recursively'
+            }
+          },
+          required: ['pattern']
+        }
+      },
+      {
+        name: 'probe_chat',
+        description: 'Ask questions about the codebase using AI agent',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            message: {
+              type: 'string',
+              description: 'Question to ask about the codebase'
+            },
+            schema: {
+              type: 'string',
+              description: 'Optional JSON schema for structured output'
+            }
+          },
+          required: ['message']
+        }
+      }
+    ]
+  }));
+
+  // Handle tool calls
+  server.setRequestHandler('tools/call', async (request) => {
+    const { name, arguments: args } = request.params;
+
+    try {
+      switch (name) {
+        case 'probe_search': {
+          const result = await searchToolInstance.execute({
+            query: args.query,
+            path: args.path,
+            allow_tests: args.allowTests,
+            exact: args.exact,
+            maxTokens: args.maxTokens,
+            language: args.language,
+            sessionId: options.sessionId || 'mcp-session'
+          });
+
+          return {
+            content: [
+              {
+                type: 'text',
+                text: typeof result === 'string' ? result : JSON.stringify(result)
+              }
+            ]
+          };
+        }
+
+        case 'probe_query': {
+          const result = await queryToolInstance.execute({
+            pattern: args.pattern,
+            path: args.path,
+            language: args.language,
+            allow_tests: args.allowTests,
+            sessionId: options.sessionId || 'mcp-session'
+          });
+
+          return {
+            content: [
+              {
+                type: 'text',
+                text: typeof result === 'string' ? result : JSON.stringify(result)
+              }
+            ]
+          };
+        }
+
+        case 'probe_extract': {
+          const result = await extractToolInstance.execute({
+            targets: args.targets,
+            context_lines: args.contextLines,
+            allow_tests: args.allowTests,
+            format: args.format,
+            sessionId: options.sessionId || 'mcp-session'
+          });
+
+          return {
+            content: [
+              {
+                type: 'text',
+                text: typeof result === 'string' ? result : JSON.stringify(result)
+              }
+            ]
+          };
+        }
+
+        case 'probe_list_files': {
+          const result = await listFilesToolInstance.execute({
+            directory: args.directory,
+            sessionId: options.sessionId || 'mcp-session'
+          });
+
+          return {
+            content: [
+              {
+                type: 'text',
+                text: typeof result === 'string' ? result : JSON.stringify(result)
+              }
+            ]
+          };
+        }
+
+        case 'probe_search_files': {
+          const result = await searchFilesToolInstance.execute({
+            pattern: args.pattern,
+            directory: args.directory,
+            recursive: args.recursive,
+            sessionId: options.sessionId || 'mcp-session'
+          });
+
+          return {
+            content: [
+              {
+                type: 'text',
+                text: typeof result === 'string' ? result : JSON.stringify(result)
+              }
+            ]
+          };
+        }
+
+        case 'probe_chat': {
+          // Create a ProbeChat instance for AI-powered responses
+          const chat = new ProbeChat({
+            allowEdit: false,
+            debug: options.debug
+          });
+
+          const result = await chat.chat(args.message, {
+            schema: args.schema
+          });
+
+          return {
+            content: [
+              {
+                type: 'text',
+                text: result
+              }
+            ]
+          };
+        }
+
+        default:
+          throw new Error(`Unknown tool: ${name}`);
+      }
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Error executing tool ${name}: ${error.message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+
+  return server;
+}
+
+/**
+ * Start MCP server with stdio transport
+ */
+export async function startMCPServer(options = {}) {
+  const server = await createMCPServer(options);
+  const transport = new StdioServerTransport();
+
+  await server.connect(transport);
+
+  console.error('Probe MCP Server started successfully');
+
+  return server;
+}
+
+// If running as standalone script
+if (import.meta.url === `file://${process.argv[1]}`) {
+  startMCPServer({
+    debug: process.env.DEBUG === '1'
+  }).catch(error => {
+    console.error('Failed to start MCP server:', error);
+    process.exit(1);
+  });
+}

package/data/probe/examples/chat/npm/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2024 Leonid Bugaev
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 

package/data/probe/examples/chat/npm/README.md

@@ -0,0 +1,168 @@
+# @probelabs/probe-chat
+
+A CLI chat interface for the [probe](https://github.com/probelabs/probe) code search tool.
+
+## Installation
+
+### Global Installation (Recommended)
+
+```bash
+npm install -g @probelabs/probe-chat
+```
+
+### Local Installation
+
+```bash
+npm install @probelabs/probe-chat
+```
+
+## Features
+
+- **Interactive Chat**: Talk to an AI assistant that can search your codebase
+- **Code Search**: Uses the powerful Probe code search tool under the hood
+- **Multiple LLM Support**: Works with both Anthropic Claude and OpenAI models
+- **AI SDK Integration**: Built on the [Vercel AI SDK](https://sdk.vercel.ai/) for robust AI capabilities
+- **CLI Interface**: Easy-to-use command-line interface
+- **Session Management**: Maintains chat history and provides usage statistics
+- **Customizable**: Configure search folders, models, and more
+
+## Usage
+
+### Command Line Interface
+
+```bash
+# Basic usage (searches in current directory)
+probe-chat
+
+# Search in a specific directory
+probe-chat /path/to/your/project
+
+# Enable debug mode
+probe-chat --debug /path/to/your/project
+
+# Specify a model to use
+probe-chat --model claude-3-7-sonnet-latest /path/to/your/project
+```
+
+### Environment Variables
+
+You can configure the chat using environment variables:
+
+- `ANTHROPIC_API_KEY`: Your Anthropic API key
+- `OPENAI_API_KEY`: Your OpenAI API key
+- `MODEL_NAME`: The model to use (e.g., 'claude-3-7-sonnet-latest', 'gpt-4o-2024-05-13')
+- `ALLOWED_FOLDERS`: Comma-separated list of folders to search in
+- `DEBUG`: Set to 'true' to enable debug mode
+- `ANTHROPIC_API_URL`: Custom Anthropic API URL (optional)
+- `OPENAI_API_URL`: Custom OpenAI API URL (optional)
+
+### Chat Commands
+
+While in the chat, you can use the following commands:
+
+- `exit` or `quit`: End the chat session
+- `usage`: Display token usage statistics
+- `clear`: Clear the chat history
+
+## Programmatic Usage
+
+You can also use the package programmatically in your Node.js applications:
+
+```javascript
+import { ProbeChat, tools } from '@probelabs/probe-chat';
+
+// Create a new chat instance
+const chat = new ProbeChat({
+  debug: true,
+  model: 'claude-3-7-sonnet-latest',
+  anthropicApiKey: 'your-api-key',
+  allowedFolders: ['/path/to/your/project']
+});
+
+// Get a response from the chat
+const response = await chat.chat('How is the authentication implemented in this codebase?');
+console.log(response);
+
+// Get token usage statistics
+const usage = chat.getTokenUsage();
+console.log(`Request tokens: ${usage.request}`);
+console.log(`Response tokens: ${usage.response}`);
+console.log(`Total tokens: ${usage.total}`);
+
+// Clear the chat history
+chat.clearHistory();
+```
+
+## API Reference
+
+### ProbeChat Class
+
+```javascript
+import { ProbeChat } from '@probelabs/probe-chat';
+
+// Create a new chat instance
+const chat = new ProbeChat(options);
+```
+
+#### Constructor Options
+
+- `debug`: Enable debug mode (boolean)
+- `model`: Model name to use (string)
+- `anthropicApiKey`: Anthropic API key (string)
+- `openaiApiKey`: OpenAI API key (string)
+- `anthropicApiUrl`: Custom Anthropic API URL (string)
+- `openaiApiUrl`: Custom OpenAI API URL (string)
+- `allowedFolders`: Folders to search in (array of strings)
+
+#### Methods
+
+- `chat(message)`: Process a user message and get a response
+- `getSessionId()`: Get the session ID
+- `getTokenUsage()`: Get token usage statistics
+- `clearHistory()`: Clear the chat history
+
+### Tools
+
+The package also exports the tools from `@probelabs/probe` for convenience:
+
+```javascript
+import { tools } from '@probelabs/probe-chat';
+
+// Access the tools
+const { searchTool, queryTool, extractTool } = tools;
+
+// Access the default system message
+const systemMessage = tools.DEFAULT_SYSTEM_MESSAGE;
+```
+
+## Supported Models
+
+### Anthropic Models
+- `claude-3-7-sonnet-latest` (default)
+- `claude-3-7-opus-latest`
+- `claude-3-5-sonnet-20241022`
+- `claude-3-5-sonnet-20240620`
+- `claude-3-opus-20240229`
+- `claude-3-sonnet-20240229`
+- `claude-3-haiku-20240307`
+
+### OpenAI Models
+- `gpt-4o-2024-05-13` (default)
+- `gpt-4o`
+- `gpt-4-turbo`
+- `gpt-4`
+
+## Requirements
+
+- Node.js 18.0.0 or higher
+- An API key from either Anthropic or OpenAI
+
+## License
+
+ISC
+
+## Related Projects
+
+- [probe](https://github.com/probelabs/probe) - The core probe code search tool
+- [@probelabs/probe](https://www.npmjs.com/package/@probelabs/probe) - Node.js wrapper for the probe tool
+- [Vercel AI SDK](https://sdk.vercel.ai/) - The AI SDK used for model integration 

package/data/probe/examples/chat/npm/bin/probe-chat.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+
+/**
+ * @probelabs/probe-chat CLI
+ * Command-line interface for Probe code search chat
+ */
+
+import 'dotenv/config';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import { Command } from 'commander';
+import { existsSync, realpathSync } from 'fs';
+import { resolve } from 'path';
+import { generateText } from 'ai';
+import { ProbeChat } from '../index.js';
+
+// Create a new instance of the program
+const program = new Command();
+
+// Configure the program
+program
+  .name('probe-chat')
+  .description('CLI chat interface for Probe code search')
+  .version('1.0.0')
+  .option('-d, --debug', 'Enable debug mode')
+  .option('-m, --model <model>', 'Specify the model to use')
+  .argument('[path]', 'Path to the codebase to search (overrides ALLOWED_FOLDERS)')
+  .parse(process.argv);
+
+// Get the options
+const options = program.opts();
+
+// Get the path argument
+const pathArg = program.args[0];
+
+// Set debug mode if specified
+if (options.debug) {
+  process.env.DEBUG_CHAT = 'true';
+  console.log(chalk.yellow('Debug mode enabled'));
+}
+
+// Set model if specified
+if (options.model) {
+  process.env.MODEL_NAME = options.model;
+  console.log(chalk.blue(`Using model: ${options.model}`));
+}
+
+// Set ALLOWED_FOLDERS if path is provided
+if (pathArg) {
+  const resolvedPath = resolve(pathArg);
+
+  // Check if the path exists
+  if (existsSync(resolvedPath)) {
+    // Get the real path (resolves symlinks)
+    const realPath = realpathSync(resolvedPath);
+
+    // Set the ALLOWED_FOLDERS environment variable
+    process.env.ALLOWED_FOLDERS = realPath;
+    console.log(chalk.blue(`Using codebase path: ${realPath}`));
+  } else {
+    console.error(chalk.red(`Error: Path does not exist: ${resolvedPath}`));
+    process.exit(1);
+  }
+}
+
+// Initialize the chat
+let chat;
+try {
+  chat = new ProbeChat();
+
+  // Print the model being used
+  if (chat.apiType === 'anthropic') {
+    console.log(chalk.green(`Using Anthropic API with model: ${chat.model}`));
+  } else {
+    console.log(chalk.green(`Using OpenAI API with model: ${chat.model}`));
+  }
+
+  // Print the session ID
+  console.log(chalk.blue(`Session ID: ${chat.getSessionId()}`));
+
+  console.log(chalk.cyan('Type "exit" or "quit" to end the chat'));
+  console.log(chalk.cyan('Type "usage" to see token usage statistics'));
+  console.log(chalk.cyan('Type "clear" to clear the chat history'));
+  console.log(chalk.cyan('-------------------------------------------'));
+} catch (error) {
+  console.error(chalk.red(`Error initializing chat: ${error.message}`));
+  process.exit(1);
+}
+
+// Function to format the AI response
+function formatResponse(response) {
+  // Replace tool calls with colored versions
+  return response.replace(
+    /<tool_call>(.*?)<\/tool_call>/gs,
+    (match, toolCall) => chalk.magenta(`[Tool Call] ${toolCall}`)
+  );
+}
+
+// Main chat loop
+async function startChat() {
+  while (true) {
+    const { message } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'message',
+        message: chalk.blue('You:'),
+        prefix: '',
+      },
+    ]);
+
+    // Handle special commands
+    if (message.toLowerCase() === 'exit' || message.toLowerCase() === 'quit') {
+      console.log(chalk.yellow('Goodbye!'));
+      break;
+    } else if (message.toLowerCase() === 'usage') {
+      const usage = chat.getTokenUsage();
+      console.log(chalk.cyan('Token Usage:'));
+      console.log(chalk.cyan(`  Request tokens: ${usage.request}`));
+      console.log(chalk.cyan(`  Response tokens: ${usage.response}`));
+      console.log(chalk.cyan(`  Total tokens: ${usage.total}`));
+      continue;
+    } else if (message.toLowerCase() === 'clear') {
+      const newSessionId = chat.clearHistory();
+      console.log(chalk.yellow('Chat history cleared'));
+      console.log(chalk.blue(`New session ID: ${newSessionId}`));
+      continue;
+    }
+
+    // Show a spinner while waiting for the response
+    const spinner = ora('Thinking...').start();
+
+    try {
+      // Get response from the chat
+      const response = await chat.chat(message);
+
+      // Stop the spinner
+      spinner.stop();
+
+      // Print the formatted response
+      console.log(chalk.green('Assistant:'));
+      console.log(formatResponse(response));
+      console.log(); // Add a blank line for readability
+    } catch (error) {
+      // Stop the spinner and show the error
+      spinner.stop();
+      console.error(chalk.red(`Error: ${error.message}`));
+    }
+  }
+}
+
+// Start the chat
+startChat().catch((error) => {
+  console.error(chalk.red(`Fatal error: ${error.message}`));
+  process.exit(1);
+});