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

package/data/probe/site/quick-start.md

@@ -0,0 +1,289 @@
+# Quick Start
+
+This guide will help you get up and running with Probe quickly. For more detailed information, check out the other sections of the documentation.
+
+## Installation
+
+The easiest way to install Probe is via npm:
+
+```bash
+npm install -g @probelabs/probe@latest
+```
+
+Or using curl (for macOS and Linux):
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/probelabs/probe/main/install.sh | bash
+```
+
+Or using PowerShell (for Windows):
+
+```powershell
+iwr -useb https://raw.githubusercontent.com/probelabs/probe/main/install.ps1 | iex
+```
+
+For more detailed installation instructions, including manual installation and building from source, see the [Installation Guide](/installation).
+
+## Basic Search Example
+
+Search for code containing the phrase "llm pricing" in the current directory:
+
+```bash
+probe search "llm pricing" ./
+```
+
+This will search for the terms "llm" and "pricing" in your codebase and return the most relevant code blocks.
+
+For more advanced search techniques and options, see the [Search Functionality](/search-functionality) documentation.
+
+## Advanced Search (with Token Limiting)
+
+Search for "prompt injection" in the current directory but limit the total tokens to 10000 (useful for AI tools with context window constraints):
+
+```bash
+probe search "prompt injection" ./ --max-tokens 10000
+```
+
+This is particularly useful when you need to feed the results into an AI model with a limited context window. Learn more about AI integration in the [AI Integration Overview](/ai-integration).
+
+## Session-Based Caching
+
+Use session IDs to avoid seeing the same code blocks multiple times in related searches:
+
+```bash
+# First search - generates a session ID
+probe search "authentication" --session ""
+# Session: a1b2 (example output)
+
+# Subsequent searches - reuse the session ID
+probe search "login" --session "a1b2"
+# Will skip code blocks already shown in the previous search
+```
+
+In Node.js applications:
+
+```javascript
+import { search } from '@probelabs/probe';
+
+// First search with empty session string (generates a session ID)
+const results1 = await search({
+  path: '/path/to/your/project',
+  query: 'authentication',
+  session: ''
+});
+
+// Get the session ID from the results
+const sessionId = results1.session;
+
+// Use the same session ID for related searches
+const results2 = await search({
+  path: '/path/to/your/project',
+  query: 'login',
+  session: sessionId
+});
+```
+
+This is especially useful when performing multiple related searches, as it helps avoid duplicate results and provides a more cohesive search experience.
+
+## Elastic Search Queries
+
+Use advanced query syntax for more powerful searches:
+
+```bash
+# Use AND operator for terms that must appear together
+probe search "error AND handling" ./
+
+# Use OR operator for alternative terms
+probe search "login OR authentication OR auth" ./src
+
+# Group terms with parentheses for complex queries
+probe search "(error OR exception) AND (handle OR process)" ./
+
+# Use wildcards for partial matching
+probe search "auth* connect*" ./
+
+# Exclude terms with NOT operator
+probe search "database NOT sqlite" ./
+```
+
+For a complete reference of search syntax and capabilities, see the [Search Functionality](/search-functionality#elastic-search-syntax) documentation.
+
+## Extract Code Blocks
+
+Extract a specific function or code block containing line 42 in main.rs:
+
+```bash
+probe extract src/main.rs:42
+```
+
+This will use tree-sitter to find the closest suitable parent node (function, struct, class, etc.) for that line.
+
+You can even pipe failing test output and it will extract needed files and AST out of it:
+
+```bash
+go test | probe extract
+```
+
+Extract code with LLM prompt and instructions for AI integration:
+
+```bash
+# Extract with engineer prompt template
+probe extract src/auth.rs#authenticate --prompt engineer --instructions "Explain this authentication function"
+
+# Extract with architect prompt template
+probe extract src/api.js --prompt architect --instructions "Analyze this API module"
+```
+
+To learn more about code extraction features, see the [Code Extraction](/code-extraction) documentation.
+
+## Query Code Structures
+
+Find specific code structures using tree-sitter patterns:
+
+```bash
+# Find JavaScript functions
+probe query "function $NAME($$$PARAMS) $$$BODY" ./src --language javascript
+
+# Find Python functions
+probe query "def $NAME($$$PARAMS): $$$BODY" ./src --language python
+
+# Find Go structs
+probe query "type $NAME struct { $$$FIELDS }" ./src --language go
+```
+
+The query command uses tree-sitter patterns to find specific code structures in your codebase. This is more precise than text-based search and understands the syntax of the programming language.
+
+For more details on the query command, see the [CLI Mode](/cli-mode#query-command) documentation.
+
+## Interactive AI Chat
+Use the built-in AI assistant with web interface for the best code search experience:
+
+```bash
+# Run directly with npx (no installation needed)
+npx -y @probelabs/probe-chat@latest --web
+npx -y @probelabs/probe-chat@latest
+
+# Set your API key first
+export ANTHROPIC_API_KEY=your_api_key
+# Or for OpenAI
+# export OPENAI_API_KEY=your_api_key
+
+# Specify a directory to search (optional)
+npx -y @probelabs/probe-chat@latest /path/to/your/project
+```
+
+Example questions you might ask:
+- "How does the ranking algorithm work?"
+- "Explain the file structure of this project"
+- "What are the main components of the search functionality?"
+
+For more details on the AI chat capabilities, see the [AI Chat Mode](/ai-chat) documentation.
+
+## MCP Server Integration
+
+Integrate with any AI editor by adding this to your MCP configuration:
+
+```json
+{
+  "mcpServers": {
+    "memory": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@probelabs/probe",
+        "mcp"
+      ]
+    }
+  }
+}
+```
+
+Example queries you can use with your AI assistant:
+- "Do the probe and search my codebase for implementations of the ranking algorithm"
+- "Using probe find all functions related to error handling in the src directory"
+
+For more information on MCP integration, see the [MCP Integration](/mcp-integration) and [MCP Server](/mcp-server) documentation.
+
+## Node.js SDK Usage
+
+Use Probe programmatically in your Node.js applications:
+
+```javascript
+import { search, query, extract } from '@probelabs/probe';
+
+// Search for code
+const searchResults = await search({
+  path: '/path/to/your/project',
+  query: 'authentication',
+  maxResults: 10
+});
+
+// Query for specific code structures
+const queryResults = await query({
+  path: '/path/to/your/project',
+  pattern: 'function $NAME($$$PARAMS) $$$BODY',
+  language: 'javascript'
+});
+
+// Extract code blocks
+const extractResults = await extract({
+  files: ['/path/to/your/project/src/main.js:42']
+});
+
+// Extract with LLM prompt and instructions
+const extractWithPrompt = await extract({
+  files: ['/path/to/your/project/src/auth.js#authenticate'],
+  prompt: 'engineer',
+  instructions: 'Explain this authentication function'
+});
+
+console.log(searchResults);
+```
+
+For comprehensive documentation on the Node.js SDK, see the [Node.js SDK](/nodejs-sdk) documentation.
+
+## Choose Your Path
+
+Depending on how you plan to use Probe, we have specific guides tailored to different user needs:
+
+### I am an AI Code Editor User
+
+If you want to integrate Probe with your AI-powered code editor (like Cline, GitHub Copilot, or other MCP-compatible assistants):
+
+- [Integrating Probe into AI Code Editors](/use-cases/integrating-probe-into-ai-code-editors) - Set up the MCP server, configure your editor, and start asking questions about your code
+
+### I am a CLI Power User
+
+If you need advanced text-based queries or want to feed code blocks into LLMs:
+
+- [Advanced CLI: Speed, Token Limits, and Large Repos](/use-cases/advanced-cli) - Learn techniques for handling large codebases, optimizing token usage, and integrating with other CLI tools
+
+### I am a Team Admin
+
+If you're looking for a centralized server or chat interface for your team:
+
+- [Deploying the Probe Web Interface](/use-cases/deploying-probe-web-interface) - Set up a Docker-based deployment, manage security, and configure for team usage
+
+### I am an AI Tooling Developer
+
+If you want to embed Probe programmatically into your Node.js or Python tools:
+
+- [Building AI Tools on Probe](/use-cases/building-ai-tools) - Use the Node.js SDK, integrate with LangChain or Vercel AI SDK, and build custom AI-powered code tools
+
+### Automating Workflows
+
+If you want to integrate Probe into your CI/CD or development workflows:
+
+- [GitHub Actions Integration](/integrations/github-actions) - Automate issue responses and PR reviews using Probe directly within GitHub.
+
+## Reference Documentation
+
+For comprehensive reference information:
+
+- [CLI Reference (Commands & Flags)](/cli-mode) - Complete command-line reference
+- [AI Integration Overview](/ai-integration) - Overview of all AI capabilities
+- [MCP Protocol & Tools Reference](/mcp-server) - Detailed MCP server documentation
+- [Node.js SDK API Reference](/nodejs-sdk) - Complete SDK API reference
+- [Output Formats Reference](/output-formats) - JSON, XML, and other output formats
+- [How It Works](/how-it-works) - Understand the technology behind Probe
+- [Language Support](/language-support-overview) - See how Probe understands different programming languages

package/data/probe/site/search-functionality.md

@@ -0,0 +1,291 @@
+# Search Functionality Reference
+
+Complete reference documentation for Probe's search capabilities, including query syntax, ranking algorithms, and advanced search techniques.
+
+## SEARCH COMMAND
+
+```bash
+probe search <QUERY> [PATH] [OPTIONS]
+```
+
+### CORE PARAMETERS
+
+| Parameter | Description |
+|-----------|-------------|
+| `<QUERY>` | **Required**: Search terms or expression |
+| `[PATH]` | Directory to search (defaults to current directory) |
+
+### KEY OPTIONS
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `--files-only` | List matching files without code blocks | Off |
+| `--ignore <PATTERN>` | Additional patterns to ignore | None |
+| `--exclude-filenames, -n` | Exclude filenames from matching | Off |
+| `--reranker, -r <TYPE>` | Ranking algorithm: `hybrid`, `hybrid2`, `bm25`, `tfidf` | `hybrid` |
+| `--frequency, -s` | Enable smart token matching | On |
+| `--max-results <N>` | Limit number of results | No limit |
+| `--max-bytes <N>` | Limit total bytes of code returned | No limit |
+| `--max-tokens <N>` | Limit total tokens | No limit |
+| `--allow-tests` | Include test files and code | Off |
+| `--any-term` | Match any search term (OR logic) | Off |
+| `--no-merge` | Keep code blocks separate | Off |
+| `--merge-threshold <N>` | Max lines between blocks to merge | 5 |
+| `--session <ID>` | Session ID for caching results | None |
+| `--format <TYPE>` | Output format: `color`, `plain`, `markdown`, `json` | `color` |
+
+For complete option details, see `probe search --help`.
+
+## QUERY PROCESSING
+
+Probe enhances search queries through several techniques:
+
+### TOKENIZATION
+
+Breaks down terms into tokens:
+```
+findUserByEmail → [find, user, by, email]
+```
+
+### STEMMING
+
+Reduces words to their root form:
+```
+implementing, implementation → implement
+```
+
+### SMART PATTERN GENERATION
+
+- **Term Boundaries**: Understands where code tokens start/end
+- **Case Handling**: Works with camelCase, snake_case, etc.
+- **Compound Handling**: Breaks down compound terms
+
+## QUERY SYNTAX
+
+Probe supports an Elasticsearch-like query syntax:
+
+### BASIC TERMS
+
+```bash
+probe search "authentication"  # Single term
+probe search "user authentication"  # Multiple terms (AND logic)
+```
+
+### BOOLEAN OPERATORS
+
+```bash
+probe search "error AND handling"  # Require both terms
+probe search "login OR authentication"  # Match either term
+probe search "database NOT sqlite"  # Exclude term
+```
+
+### GROUPING
+
+```bash
+probe search "(error OR exception) AND (handle OR process)"
+```
+
+### TERM MODIFIERS
+
+```bash
+probe search "+authentication login"  # Required term
+probe search "database -sqlite"  # Excluded term
+probe search "\"handle error\""  # Exact phrase
+```
+
+### FIELD SPECIFIERS
+
+```bash
+probe search "function:authenticate"  # Search in function names
+```
+
+### SEARCH HINTS
+
+Search hints allow you to filter results by file properties. These filters are applied at the file discovery stage and removed from the query before content searching:
+
+```bash
+probe search "error AND ext:rs"              # Only search in .rs files
+probe search "class AND file:src/**/*.py"    # Only search in Python files under src/
+probe search "function AND dir:tests"        # Only search in files under tests/ directory
+probe search "struct AND type:rust"          # Only search in Rust files
+probe search "component AND lang:javascript" # Only search in JavaScript files
+```
+
+**Available Search Hints:**
+
+| Hint | Description | Examples |
+|------|-------------|----------|
+| `ext:<extension>` | Filter by file extension | `ext:rs`, `ext:py,js,ts` |
+| `file:<pattern>` | Filter by file path pattern (supports globs) | `file:src/**/*.rs`, `file:*test*` |
+| `path:<pattern>` | Alias for `file:` | `path:src/main.rs` |
+| `dir:<pattern>` | Filter by directory pattern | `dir:src`, `dir:tests` |
+| `type:<filetype>` | Filter by ripgrep file type | `type:rust`, `type:javascript` |
+| `lang:<language>` | Filter by programming language | `lang:rust`, `lang:python` |
+
+**Combining Search Hints:**
+
+```bash
+# Multiple filters (all must match)
+probe search "config AND ext:rs AND dir:src"
+
+# Multiple extensions (any can match)
+probe search "import AND ext:js,ts,jsx,tsx"
+
+# Complex combinations
+probe search "(error OR exception) AND ext:rs AND file:src/**/*"
+```
+
+### WILDCARDS
+
+```bash
+probe search "auth*"  # Matches "auth", "authentication", "authorize", etc.
+```
+
+## RANKING ALGORITHMS
+
+Probe uses sophisticated algorithms to rank search results:
+
+### TF-IDF RANKING
+
+Term Frequency-Inverse Document Frequency balances how often terms appear in a specific code block against how common they are across the codebase.
+
+#### HOW IT WORKS
+
+1. **Term Frequency (TF)**: How often a term appears in a code block
+   ```
+   TF(term, block) = (Number of times term appears in block) / (Total number of terms in block)
+   ```
+
+2. **Inverse Document Frequency (IDF)**: Measures how unique or rare a term is
+   ```
+   IDF(term) = ln(Total number of blocks / Number of blocks containing term)
+   ```
+
+3. **TF-IDF Score**: Combines these factors
+   ```
+   TF-IDF(term, block) = TF(term, block) * IDF(term)^2
+   ```
+
+Key benefits:
+- Rewards matches on rare, important terms
+- Penalizes common terms that appear everywhere
+- Considers term frequency within each code block
+
+### BM25 RANKING
+
+BM25 (Best Matching 25) is an improved version of TF-IDF that addresses some of its limitations.
+
+#### HOW IT WORKS
+
+```
+BM25(block, query) = ∑ IDF(term) * (TF(term, block) * (k1 + 1)) / (TF(term, block) + k1 * (1 - b + b * (block_length / average_block_length)))
+```
+
+Where:
+- `k1` (1.2): Controls term frequency saturation
+- `b` (0.75): Controls length normalization
+
+Key benefits:
+- Better handling of document length
+- Diminishing returns for repeated terms
+- More accurate for longer code blocks
+- Improved handling of edge cases
+
+### HYBRID RANKING
+
+Probe's default ranking algorithm combines multiple signals for superior results.
+
+#### HOW IT WORKS
+
+The hybrid algorithm considers:
+
+1. **Combined score**: Weighted combination of TF-IDF and BM25
+   ```
+   Combined = α * TF-IDF + (1-α) * BM25
+   ```
+
+2. **Position weights**: Terms in function names, class names, and identifiers receive higher scores
+
+3. **Block metrics**:
+   - Number of unique terms matched
+   - Total matches in the block
+   - Block type (methods score higher than comments)
+
+4. **File metrics**:
+   - File match rank
+   - Number of unique terms in the file
+   - Total matches in the file
+
+Key benefits:
+- More balanced scoring across different code structures
+- Better handling of both short and long code blocks
+- Prioritizes meaningful code over comments or boilerplate
+
+### HYBRID2 RANKING
+
+An enhanced version of the hybrid algorithm with improved relevance:
+- Better normalization of scores across different metrics
+- Enhanced weighting for structural elements
+- Improved handling of term proximity
+- More sophisticated position weighting
+
+## PRACTICAL EXAMPLES
+
+### FINDING ERROR HANDLING CODE
+
+```bash
+probe search "error handling try catch"
+```
+
+This search:
+1. Tokenizes to: ["error", "handl", "try", "catch"]
+2. Matches files containing these terms
+3. Ranks results based on term frequency and importance
+4. Returns complete code blocks with error handling logic
+
+### SEARCHING FOR AUTHENTICATION FLOWS
+
+```bash
+probe search "(login OR authenticate) AND (user OR account) NOT test"
+```
+
+This complex query:
+1. Finds code with either "login" or "authenticate"
+2. Requires either "user" or "account" to be present
+3. Excludes results containing "test"
+4. Returns ranked, complete code blocks
+
+### FINDING SPECIFIC API ENDPOINTS
+
+```bash
+probe search "function:create* api endpoint"
+```
+
+This search:
+1. Targets functions starting with "create"
+2. Requires "api" and "endpoint" terms
+3. Returns complete function definitions
+4. Ranks results with the most relevant endpoints first
+
+### LIMITING RESULTS FOR AI INTEGRATION
+
+```bash
+probe search "database connection pool" --max-tokens 4000 --format json
+```
+
+This search:
+1. Finds code related to database connection pools
+2. Limits results to fit within 4000 tokens
+3. Returns JSON-formatted output suitable for AI processing
+
+## PERFORMANCE TIPS
+
+- **Be specific**: More specific queries yield more relevant results
+- **Use field specifiers**: Target specific code elements with `function:`, `class:`, etc.
+- **Leverage boolean operators**: Combine terms with AND, OR, NOT for precision
+- **Control result size**: Use `--max-results`, `--max-bytes`, or `--max-tokens` for large codebases
+- **Session caching**: Use `--session` to avoid seeing the same code blocks repeatedly
+- **Experiment with rankers**: Try different ranking algorithms for different types of searches
+
+For more information on how Probe works internally, see [How Probe Works](how-it-works.md).
+For details on code extraction, see [Code Extraction](code-extraction.md).