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

package/data/probe/site/use-cases/advanced-cli.md

@@ -0,0 +1,253 @@
+# Advanced CLI: Speed, Token Limits, and Large Repos
+
+This guide covers advanced techniques for using Probe's command-line interface effectively, especially when working with large codebases and integrating with AI tools.
+
+## Overview
+
+Probe's CLI is designed for performance and flexibility, but working with large repositories or preparing results for AI models requires some additional techniques. This guide will show you how to optimize your workflow for speed, manage token limits, and effectively handle large codebases.
+
+## Merging Code Blocks and Session-Based Caching
+
+### Controlling Block Merging
+
+By default, Probe merges adjacent code blocks to provide better context. You can control this behavior:
+
+```bash
+# Disable merging completely
+probe search "authentication" --no-merge
+
+# Adjust the threshold for merging (default is 5 lines)
+probe search "authentication" --merge-threshold 10
+```
+
+When to use:
+- Use `--no-merge` when you need precise, separate results
+- Increase `--merge-threshold` when you want more context between related blocks
+- Decrease `--merge-threshold` for more focused results
+
+### Session-Based Caching
+
+When performing multiple related searches, use session-based caching to avoid seeing the same code blocks repeatedly:
+
+```bash
+# First search - generates a session ID
+probe search "authentication" --session ""
+# Session: a1b2c3d4 (example output)
+
+# Subsequent searches - reuse the session ID
+probe search "login" --session "a1b2c3d4"
+# Will skip code blocks already shown in the previous search
+```
+
+This is particularly useful when:
+- Exploring a topic with multiple related searches
+- Working with AI assistants to avoid repetitive results
+- Building up a comprehensive understanding of a feature
+
+## Dealing with Huge Monorepos
+
+Large monorepos present unique challenges. Here are strategies to handle them effectively:
+
+### Targeted Directory Searches
+
+Instead of searching the entire repository, target specific directories:
+
+```bash
+# Search only in the authentication module
+probe search "password reset" ./src/auth
+
+# Search multiple specific directories
+probe search "user profile" ./src/users ./src/profiles ./src/auth
+```
+
+### Custom Ignore Patterns
+
+Use custom ignore patterns to exclude irrelevant directories:
+
+```bash
+# Exclude generated code, tests, and third-party libraries
+probe search "api" --ignore "node_modules,dist,build,vendor,test,__tests__"
+```
+
+### Two-Phase Search Approach
+
+For very large repositories, use a two-phase approach:
+
+```bash
+# Phase 1: Find relevant files
+probe search "authentication" --files-only > auth-files.txt
+
+# Phase 2: Search only in those files
+cat auth-files.txt | xargs probe search "password reset"
+```
+
+### Parallel Processing
+
+For extremely large codebases, split the search across multiple processes:
+
+```bash
+# Split the search across multiple directories
+find ./src -type d -maxdepth 1 | xargs -P 4 -I {} probe search "error handling" {} --format json
+```
+
+## Scripting with grep, xargs, etc.
+
+Probe integrates well with standard Unix tools for powerful workflows:
+
+### Piping and Filtering
+
+```bash
+# Find code, then filter with grep
+probe search "database" | grep "connection"
+
+# Process results with awk
+probe search "function" --format plain | awk '/export/ {print $0}'
+
+# Count occurrences
+probe search "TODO" --format plain | grep -c "TODO"
+```
+
+### Advanced xargs Usage
+
+```bash
+# Extract code from all files matching a pattern
+probe search "class" --files-only | xargs -I {} probe extract {}
+
+# Process multiple search terms
+echo -e "auth\nuser\nprofile" | xargs -I {} probe search "{}" ./src
+```
+
+### Creating Custom Reports
+
+```bash
+# Generate a markdown report of all TODO comments
+probe search "TODO" --format markdown > todo-report.md
+
+# Create a JSON report of error handling patterns
+probe search "try|catch|error" --format json > error-handling.json
+```
+
+## Token-Limiting for AI Context Windows
+
+When using Probe with AI models, managing token count is crucial:
+
+### Limiting Output Size
+
+```bash
+# Limit by token count (for AI context windows)
+probe search "authentication flow" --max-tokens 8000
+
+# Limit by byte size
+probe search "authentication flow" --max-bytes 16000
+
+# Limit by result count
+probe search "authentication flow" --max-results 5
+```
+
+### Format Selection for AI
+
+Different AI models work better with different formats:
+
+```bash
+# Markdown format for most AI models
+probe search "authentication" --format markdown
+
+# Plain text for simpler models
+probe search "authentication" --format plain
+
+# JSON for programmatic processing
+probe search "authentication" --format json
+```
+
+### Optimizing for Token Efficiency
+
+```bash
+# Exclude filenames to save tokens
+probe search "authentication" --exclude-filenames
+
+# Use more specific search terms to reduce noise
+probe search "authentication function"
+
+# Focus on specific file types
+probe search "authentication" ./src --ignore "*.test.js,*.spec.js,*.css,*.html"
+```
+
+## Performance Optimization Techniques
+
+### Search Speed Optimization
+
+```bash
+# Use frequency-based search (default)
+probe search "authentication" --frequency
+
+# Use more specific search terms for better precision
+probe search "exactString function"
+
+# Search only filenames first, then content
+probe search "config" --files-only
+```
+
+### Result Ranking Control
+
+```bash
+# Use different ranking algorithms
+probe search "authentication" --reranker hybrid  # Default
+probe search "authentication" --reranker bm25    # Better for longer documents
+probe search "authentication" --reranker tfidf   # Classic algorithm
+```
+
+### Memory Usage Optimization
+
+For very large repositories or limited memory environments:
+
+```bash
+# Process files in smaller batches
+find ./src -name "*.js" | split -l 100 - batch_
+for batch in batch_*; do
+  probe search "memory leak" $(cat $batch)
+  rm $batch
+done
+```
+
+## Practical Examples
+
+### Finding Security Issues
+
+```bash
+# Search for common security vulnerabilities
+probe search "password|token|secret|api_key" --format markdown > security-audit.md
+
+# Look for SQL injection vulnerabilities
+probe search "exec|eval|SELECT.*FROM.*WHERE" --format json > sql-injection-check.json
+```
+
+### Code Quality Analysis
+
+```bash
+# Find TODO comments
+probe search "TODO|FIXME|HACK" > todos.txt
+
+# Look for large functions
+probe query "function $NAME($$$PARAMS) $$$BODY" ./src --language javascript > large-functions.txt
+
+# Find deprecated API usage
+probe search "deprecated" --format markdown > deprecated-usage.md
+```
+
+### Documentation Generation
+
+```bash
+# Extract all exported functions
+probe query "export function $NAME($$$PARAMS) $$$BODY" ./src --language typescript > exported-functions.txt
+
+# Generate API documentation
+probe query "export function $NAME($$$PARAMS) $$$BODY" ./src --language typescript | \
+  probe extract > api-docs.md
+```
+
+## Next Steps
+
+- For AI integration, see [Integrating Probe into AI Code Editors](/use-cases/integrating-probe-into-ai-code-editors)
+- For team collaboration, check out [Deploying the Probe Web Interface](/use-cases/deploying-probe-web-interface)
+- For programmatic access, explore [Building AI Tools on Probe](/use-cases/building-ai-tools)
+- For complete command reference, see the [CLI Reference (Commands & Flags)](/cli-mode)

package/data/probe/site/use-cases/ai-code-editors.md

@@ -0,0 +1,239 @@
+# Using Probe with AI Code Editors
+
+This guide explains how to integrate Probe with AI-powered code editors to enhance your coding experience with intelligent code search and understanding.
+
+## Overview
+
+AI code editors and assistants are powerful tools, but they often struggle with large codebases because they can't efficiently search and understand your entire project. Probe solves this problem by providing a specialized code search capability that AI assistants can use to find and understand relevant code.
+
+By integrating Probe with your AI code editor, you enable your AI assistant to:
+
+- Search your codebase with natural language queries
+- Find specific code structures and patterns
+- Extract complete code blocks with proper context
+- Understand the relationships between different parts of your code
+
+## Migrating from @probelabs/probe-mcp
+
+If you're currently using the standalone `@probelabs/probe-mcp` package, `probe mcp` is a **drop-in replacement**. Simply change your MCP configuration from:
+
+```json
+"args": ["-y", "@probelabs/probe-mcp"]
+```
+
+to:
+
+```json
+"args": ["-y", "@probelabs/probe", "mcp"]
+```
+
+All the same tools, parameters, and functionality - just with the integrated command!
+
+## Integration Options
+
+### 1. MCP Server Integration (Recommended)
+
+The Model Context Protocol (MCP) server integration is the most powerful way to connect Probe with AI editors. It allows the AI to directly use Probe's search capabilities through a standardized protocol.
+
+#### Setting Up MCP Integration
+
+1. **Create an MCP configuration file** in your project:
+
+   For Cline, create `.cline/mcp_config.json`:
+
+   ```json
+   {
+     "mcpServers": {
+       "probe": {
+         "command": "npx",
+         "args": [
+           "-y",
+           "@probelabs/probe",
+           "mcp"
+         ]
+       }
+     }
+   }
+   ```
+
+   For Roo, Cursor, Windsurf, and other editors, the MCP configuration follows a similar pattern. Check your editor's documentation for specific details.
+
+2. **Start your AI editor** and begin asking questions about your codebase.
+
+3. **Use natural language queries** to search your code:
+   - "Find all authentication-related functions in the project"
+   - "Show me how error handling is implemented"
+   - "Search for code that processes user input"
+
+### 2. Manual Search and Copy
+
+If your AI editor doesn't support MCP, you can still use Probe manually:
+
+1. **Run Probe searches** in your terminal:
+   ```bash
+   probe search "authentication" ./src
+   ```
+
+2. **Copy the results** into your conversation with the AI assistant.
+
+3. **Ask follow-up questions** based on the code you've shared.
+
+## Example Workflows
+
+### Exploring a New Codebase
+
+When joining a new project or exploring an unfamiliar codebase:
+
+1. **Ask for an overview**: "Can you help me understand the structure of this project?"
+2. **Explore key components**: "Show me the main entry points of the application"
+3. **Dive deeper**: "How is authentication implemented in this project?"
+
+### Implementing New Features
+
+When adding new functionality to an existing project:
+
+1. **Find similar patterns**: "Show me examples of API endpoints in this codebase"
+2. **Understand dependencies**: "What modules would I need to modify to add a new user role?"
+3. **Get implementation guidance**: "Based on the existing code, how should I implement this new feature?"
+
+### Debugging Issues
+
+When troubleshooting problems:
+
+1. **Find error handling**: "Show me how errors are handled in the authentication flow"
+2. **Trace execution paths**: "Find all places where user input is validated"
+3. **Identify patterns**: "Are there similar issues elsewhere in the codebase?"
+
+## Editor-Specific Setup
+
+### Cline
+
+1. Create `.cline/mcp_config.json` with the configuration shown above
+2. Start Cline in your project directory
+3. Ask questions about your codebase
+
+### Roo Code
+
+1. Visit [Roo Code on GitHub](https://github.com/RooVetGit/Roo-Code) for installation instructions
+2. Configure Roo to use Probe via MCP
+3. Roo can be configured the same way as other editors via MCP
+
+### VSCode with Cursor or Windsurf
+
+1. Install the Cursor or Windsurf extension
+2. Configure the extension to use external tools
+3. Add the Probe MCP configuration to your settings
+
+## Advanced Configuration
+
+### Custom Search Paths
+
+You can configure the MCP server to search specific directories by default:
+
+```json
+{
+  "mcpServers": {
+    "probe": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@probelabs/probe",
+        "mcp"
+      ],
+      "env": {
+        "PROBE_DEFAULT_PATHS": "/path/to/project1,/path/to/project2"
+      }
+    }
+  }
+}
+```
+
+### Limiting Results
+
+For large codebases, you can limit the amount of code returned:
+
+```json
+{
+  "mcpServers": {
+    "probe": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@probelabs/probe",
+        "mcp"
+      ],
+      "env": {
+        "PROBE_MAX_TOKENS": "20000"
+      }
+    }
+  }
+}
+```
+
+## Optimizing Probe Usage in AI Editors
+
+To get the most out of Probe in your AI code editor, you can provide custom instructions to guide how the AI uses Probe's tools. Below is an example from a `.roomodes` configuration file that optimizes Probe usage:
+
+```json
+{
+  "customModes": [
+    {
+      "slug": "ask-probe",
+      "name": "Ask Probe",
+      "roleDefinition": "You are Roo, a code intelligence assistant powered by the Probe MCP tools. Always prefer Probe MCP tools for searching the code. Rather then guessing, start with using `search_code` tool, with exact keywords, and extend your search deeper. AVOID reading full files, unless absolutelly necessary. Use this tools as a scalpel, not a hammer. Use 'exact' parameter if you looking for something specific. Avoid searching with too common keywords, like 'if', 'for', 'while', etc. If you need to extract a specific code block, use `extract_code` tool. If you need to find a specific code structure, use `query_code` tool. If you are unsure about the results, refine your query or ask for clarification.",
+      "groups": [
+        "read",
+        "mcp"
+      ],
+      "customInstructions": "Leverage Probe MCP tools effectively:\n\n1. **search_code**:\n   - Use simple, unique keywords (e.g., 'rpc' over 'rpc layer')\n   - Use ElasticSearch query language: ALWAYS use + for required terms, and omit for general and optional, - for excluded terms, and AND/OR for logic. Prefer explicit searches, with this syntax.\n\n2. **query_code**:\n   - Craft tree-sitter patterns (e.g., 'fn $NAME($$$PARAMS) $$$BODY') for specific structures\n   - Match patterns to the language (e.g., Rust, Python)\n   - Use sparingly for precise structural queries\n\n3. **extract_code**:\n   - Extract blocks by line number (e.g., '/file.rs:42') or full files for context\n   - Include `contextLines` only if AST parsing fails\n\n**Approach**:\n- Start with a clear search strategy\n- Interpret results concisely, tying them to the user's question\n- If unsure, refine queries or ask for clarification"
+    }
+  ]
+}
+```
+
+This configuration instructs the AI to:
+- Use Probe MCP tools as the primary method for code search
+- Start with specific keywords rather than guessing
+- Use the appropriate tool for each task (search_code, query_code, extract_code)
+- Follow best practices for each tool, such as using ElasticSearch query syntax
+- Avoid common pitfalls like searching with overly generic terms
+
+## Best Practices
+
+1. **Be specific in your queries**: Instead of "show me the code," ask "show me the authentication implementation in the user service"
+
+2. **Provide context**: Tell the AI what you're trying to accomplish so it can formulate better searches
+
+3. **Use follow-up questions**: Build on previous results to explore the code more deeply
+
+4. **Combine with documentation**: Ask the AI to explain the code it finds by referencing project documentation
+
+5. **Iterate on searches**: If you don't find what you're looking for, try reformulating your query
+
+6. **Consider privacy implications**: Remember that when using Probe with external AI services, code snippets are sent to those services
+
+## Troubleshooting
+
+### Common Issues
+
+| Issue | Solution |
+|-------|----------|
+| AI doesn't use Probe | Explicitly ask the AI to use Probe: "Using Probe, search for..." |
+| Empty search results | Try a simpler query or check if you're searching in the right directory |
+| Too much code returned | Use more specific queries or configure result limits |
+| MCP server not starting | Check your MCP configuration and ensure npx is installed |
+| Privacy concerns with sensitive code | Use local AI models or limit searches to non-sensitive code areas |
+
+### Getting Help
+
+If you encounter issues with the MCP integration:
+
+1. Check the [MCP Server Reference](/mcp-server) for detailed information
+2. Visit the [Probe GitHub repository](https://github.com/probelabs/probe) for the latest updates
+3. Open an issue if you encounter a bug or have a feature request
+
+## Next Steps
+
+- Learn about [Probe's CLI capabilities](/cli-mode) for advanced usage
+- Explore [hosting a team chat](/use-cases/team-chat) for collaborative code exploration
+- Check out [building custom tools](/use-cases/nodejs-sdk) with the Node.js SDK