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

package/data/probe/site/documentation-maintenance.md

@@ -0,0 +1,275 @@
+# Probe Documentation Maintenance Guide
+
+This guide is for documentation maintainers and contributors. It provides technical information about the documentation structure, cross-references, and navigation configuration.
+
+## Navigation Structure
+
+The Probe documentation uses VitePress and follows a specific navigation structure designed to provide a logical organization of content.
+
+### VitePress Configuration
+
+Add this configuration to your VitePress configuration file (`.vitepress/config.js`):
+
+```javascript
+export default {
+  // ... other VitePress configuration options
+  
+  themeConfig: {
+    // ... other theme configuration options
+    
+    sidebar: {
+      '/': [
+        {
+          text: 'Getting Started',
+          collapsed: false,
+          items: [
+            { text: 'Quick Start', link: '/quick-start' },
+            { text: 'Installation', link: '/installation' },
+            { text: 'Core Features', link: '/features' },
+          ]
+        },
+        {
+          text: 'Core Functionality',
+          collapsed: false,
+          items: [
+            { text: 'How It Works', link: '/how-it-works' },
+            { text: 'Search Functionality', link: '/search-functionality' },
+            { text: 'Code Extraction', link: '/code-extraction' },
+            { text: 'CLI Mode', link: '/cli-mode' },
+          ]
+        },
+        {
+          text: 'AI Integration',
+          collapsed: false,
+          items: [
+            { text: 'AI Integration Overview', link: '/ai-integration' },
+            { text: 'AI Chat Mode', link: '/ai-chat' },
+            { text: 'MCP Server', link: '/mcp-server' },
+            { text: 'MCP Integration', link: '/mcp-integration' },
+            { text: 'Node.js SDK', link: '/nodejs-sdk' },
+            { text: 'Web Interface', link: '/web-interface' },
+          ]
+        },
+        {
+          text: 'Language Support',
+          collapsed: false,
+          items: [
+            { text: 'Language Support Overview', link: '/language-support-overview' },
+            { text: 'Supported Languages', link: '/supported-languages' },
+            { text: 'Adding Languages', link: '/adding-languages' },
+          ]
+        },
+        {
+          text: 'Advanced Topics',
+          collapsed: true,
+          items: [
+            { text: 'Result Ranking', link: '/result-ranking' },
+            { text: 'Pattern Matching', link: '/pattern-matching' },
+            { text: 'Performance Optimization', link: '/performance-optimization' },
+            { text: 'Customization', link: '/customization' },
+          ]
+        },
+        {
+          text: 'Contributing',
+          collapsed: true,
+          items: [
+            { text: 'Contributing Guide', link: '/contributing' },
+            { text: 'Code of Conduct', link: '/code-of-conduct' },
+            { text: 'Development Setup', link: '/development-setup' },
+          ]
+        },
+      ]
+    },
+    
+    nav: [
+      { text: 'Home', link: '/' },
+      { text: 'Quick Start', link: '/quick-start' },
+      { 
+        text: 'Documentation', 
+        items: [
+          { text: 'Getting Started', items: [
+            { text: 'Quick Start', link: '/quick-start' },
+            { text: 'Installation', link: '/installation' },
+            { text: 'Core Features', link: '/features' },
+          ]},
+          { text: 'Core Functionality', items: [
+            { text: 'How It Works', link: '/how-it-works' },
+            { text: 'Search Functionality', link: '/search-functionality' },
+            { text: 'Code Extraction', link: '/code-extraction' },
+            { text: 'CLI Mode', link: '/cli-mode' },
+          ]},
+          { text: 'AI Integration', items: [
+            { text: 'AI Integration Overview', link: '/ai-integration' },
+            { text: 'AI Chat Mode', link: '/ai-chat' },
+            { text: 'MCP Server', link: '/mcp-server' },
+            { text: 'MCP Integration', link: '/mcp-integration' },
+            { text: 'Node.js SDK', link: '/nodejs-sdk' },
+            { text: 'Web Interface', link: '/web-interface' },
+          ]},
+          { text: 'Language Support', items: [
+            { text: 'Language Support Overview', link: '/language-support-overview' },
+            { text: 'Supported Languages', link: '/supported-languages' },
+            { text: 'Adding Languages', link: '/adding-languages' },
+          ]},
+        ]
+      },
+      { text: 'GitHub', link: 'https://github.com/probelabs/probe' }
+    ],
+  }
+}
+```
+
+## Cross-Reference Guidelines
+
+Proper cross-referencing improves navigation, provides contextual understanding, reduces duplication, and ensures comprehensive coverage.
+
+### Cross-Reference Implementation
+
+When implementing cross-references, follow these guidelines:
+
+1. **Contextual References**: Include references where they make sense in the context of the document, not just at the end.
+
+2. **Descriptive Link Text**: Use descriptive link text that explains what the linked document contains:
+   ```markdown
+   Learn more about [how Probe works](/how-it-works)
+   ```
+   Instead of:
+   ```markdown
+   [how-it-works.md](/how-it-works)
+   ```
+
+3. **Section References**: When appropriate, link to specific sections within documents using anchor links:
+   ```markdown
+   [Search Syntax](/search-functionality#search-syntax)
+   ```
+
+4. **Related Topics Sections**: Include a "Related Topics" section at the end of each document that lists related documents.
+
+5. **Next Steps**: Where appropriate, include a "Next Steps" section that guides users to logical next documents to read.
+
+### Example Implementation
+
+Here's an example of how to implement these cross-references in a document:
+
+```markdown
+# Quick Start
+
+This guide will help you get up and running with Probe quickly.
+
+## Installation
+
+The easiest way to install Probe is via npm:
+
+```bash
+npm install -g @probelabs/probe@latest
+```
+
+For more detailed installation instructions, including manual installation and building from source, see the [Installation Guide](/installation).
+
+...
+
+## Next Steps
+
+- Learn more about the [CLI Mode](/cli-mode) for detailed command options
+- Explore the [AI Chat Mode](/ai-chat) for interactive code exploration
+- Check out the [Web Interface](/web-interface) for a browser-based experience
+- Understand [How It Works](/how-it-works) to get the most out of Probe
+
+## Related Topics
+
+- [Installation](/installation) - Detailed installation instructions
+- [CLI Mode](/cli-mode) - Command-line interface reference
+- [AI Chat Mode](/ai-chat) - Interactive CLI interface for asking questions about your code
+- [Web Interface](/web-interface) - Browser-based exploration
+```
+
+## Cross-Reference Map
+
+The following map shows how different documentation files should reference each other:
+
+### Getting Started Section
+
+- **index.md**
+  - Links to: quick-start.md, installation.md, features.md, how-it-works.md, ai-integration.md, language-support-overview.md
+  
+- **quick-start.md**
+  - Links to: installation.md, cli-mode.md, ai-chat.md, web-interface.md, how-it-works.md
+  - Referenced by: index.md, installation.md
+
+- **installation.md**
+  - Links to: quick-start.md, cli-mode.md
+  - Referenced by: index.md, quick-start.md
+
+- **features.md**
+  - Links to: how-it-works.md, search-functionality.md, code-extraction.md, ai-integration.md, language-support-overview.md
+  - Referenced by: index.md, how-it-works.md
+
+### Core Functionality Section
+
+- **how-it-works.md**
+  - Links to: search-functionality.md, code-extraction.md, features.md, language-support-overview.md
+  - Referenced by: index.md, features.md, search-functionality.md, code-extraction.md
+
+- **search-functionality.md**
+  - Links to: how-it-works.md, code-extraction.md, cli-mode.md
+  - Referenced by: how-it-works.md, features.md, cli-mode.md, language-support-overview.md
+
+- **code-extraction.md**
+  - Links to: how-it-works.md, search-functionality.md, language-support-overview.md
+  - Referenced by: how-it-works.md, features.md, search-functionality.md, language-support-overview.md
+
+- **cli-mode.md**
+  - Links to: search-functionality.md, code-extraction.md, installation.md
+  - Referenced by: quick-start.md, search-functionality.md, installation.md
+
+### AI Integration Section
+
+- **ai-integration.md**
+  - Links to: ai-chat.md, mcp-server.md, mcp-integration.md, nodejs-sdk.md, web-interface.md
+  - Referenced by: index.md, features.md
+
+- **ai-chat.md**
+  - Links to: ai-integration.md, nodejs-sdk.md
+  - Referenced by: ai-integration.md, quick-start.md, index.md
+
+- **mcp-server.md**
+  - Links to: ai-integration.md, mcp-integration.md
+  - Referenced by: ai-integration.md, mcp-integration.md
+
+- **mcp-integration.md**
+  - Links to: ai-integration.md, mcp-server.md
+  - Referenced by: ai-integration.md, index.md
+
+- **nodejs-sdk.md**
+  - Links to: ai-integration.md, ai-chat.md, web-interface.md
+  - Referenced by: ai-integration.md, index.md
+
+- **web-interface.md**
+  - Links to: ai-integration.md, nodejs-sdk.md
+  - Referenced by: ai-integration.md, quick-start.md
+
+### Language Support Section
+
+- **language-support-overview.md**
+  - Links to: supported-languages.md, adding-languages.md, search-functionality.md, code-extraction.md
+  - Referenced by: index.md, features.md, how-it-works.md
+
+- **supported-languages.md**
+  - Links to: language-support-overview.md, adding-languages.md
+  - Referenced by: language-support-overview.md
+
+- **adding-languages.md**
+  - Links to: language-support-overview.md, supported-languages.md
+  - Referenced by: language-support-overview.md
+
+## Maintenance Best Practices
+
+As the documentation evolves:
+
+1. **Update the cross-reference map** when adding new documentation files
+2. **Review existing cross-references** when updating documentation to ensure they remain relevant
+3. **Check for broken links** regularly
+4. **Ensure all document links are correct** and point to existing files
+5. **Update the navigation** when adding new documentation files
+6. **Maintain consistent formatting and style** across all documentation pages
+7. **Consider automating cross-reference validation** as part of the documentation build process

package/data/probe/site/features.md

@@ -0,0 +1,147 @@
+# What is Probe?
+
+Probe is an AI-friendly, fully local, semantic code search tool designed to power the next generation of AI coding assistants. It combines the speed of ripgrep with the understanding of tree-sitter to provide intelligent code search and extraction capabilities.
+
+## Why Probe?
+
+Most AI-assisted editors treat your code like plain text, splitting it into chunks that may or may not cover the full context—especially in large projects. **Probe** tackles this by combining ripgrep's speed with tree-sitter's AST parsing to return only the relevant blocks. No forced cloud indexing, no partial context.
+
+This means:
+
+- **Complete Context**: Get entire functions, classes, and code blocks—not just fragments.
+- **Local Processing**: Probe runs entirely locally without requiring embedding generation. Your code stays on your machine during search operations.
+- **AST Understanding**: Search based on code structure, not just text patterns.
+- **Customizable Ranking**: Fine-tune how results are sorted using BM25, TF-IDF, or hybrid approaches.
+
+## Core Capabilities
+
+### Code Understanding
+
+- **Complete Code Blocks**: Extracts entire functions, classes, or structs
+- **AST Parsing**: Understands code structure using Abstract Syntax Trees
+- **Semantic Search**: Finds code by concept and meaning
+- **Language Awareness**: Recognizes language-specific patterns
+- **Symbol Extraction**: Extracts code by function/class name
+
+### Performance
+
+- **Ripgrep Engine**: Fast initial text scanning
+- **Optimized Parsing**: Efficient AST generation
+- **Multi-Core Processing**: Parallel search operations
+- **Session-Based Caching**: Avoids duplicate results
+
+### Intelligent Ranking
+
+- **TF-IDF**: Weighs terms based on frequency and importance
+- **BM25**: Better relevance with document length normalization
+- **Hybrid Ranking**: Multiple signals combined for superior ordering
+- **Position Weighting**: Considers term position within code blocks
+
+### Query Capabilities
+
+- **Boolean Operators**: AND, OR, NOT for complex queries
+- **Grouping**: Parentheses for logical term grouping
+- **Term Modifiers**: +/- prefixes for required/excluded terms
+- **Field Specifiers**: Target specific code elements
+- **Smart Token Matching**: Stemming and compound word handling
+
+### Privacy
+
+- **Local Search Engine**: All search processing happens on your machine without requiring embedding generation
+- **No Telemetry**: Zero data collection
+- **Open Source**: Transparent codebase
+- **AI Integration Note**: When using Probe with external AI services (Anthropic, OpenAI, etc.), code snippets are sent to those services as part of the AI interaction
+
+### Language Support
+
+- **Modern Languages**: Rust, Go, Python, JavaScript/TypeScript
+- **Mainstream Languages**: Java, C++, C#, PHP
+- **Documentation**: Markdown and other text formats
+- **Language-Specific Parsing**: Tailored to each language's structure
+
+## AI Integration
+
+Probe offers powerful AI integration capabilities that allow you to leverage large language models to understand and navigate your codebase more effectively:
+
+- **[AI Chat Mode](./ai-chat.md)**: Interactive CLI interface for asking questions about your codebase
+- **[MCP Server Integration](./mcp-integration.md)**: Seamless integration with AI editors and assistants
+- **[Node.js SDK](./nodejs-sdk.md)**: Programmatic access to Probe's code search capabilities
+
+### AI-Specific Features
+
+- **Token-Aware**: Limits results to fit AI context windows
+- **Structured Output**: AI-friendly formats (JSON, XML)
+- **Multi-Model Support**: Works with various LLM models
+- **Streaming Responses**: Real-time AI interaction
+- **OpenTelemetry Tracing**: Comprehensive monitoring and observability for AI interactions
+
+## Usage Modes
+
+Probe can be used in multiple ways, depending on your workflow:
+
+- **[CLI Mode](./cli-mode.md)**: Direct command-line interface
+- **[MCP Server](./mcp-server.md)**: Integration with AI tools
+- **[AI Chat](./ai-chat.md)**: Interactive AI assistant
+- **[Web Interface](./web-interface.md)**: Browser-based exploration
+- **[Node.js SDK](./nodejs-sdk.md)**: Programmatic access
+
+## Advanced Features
+
+### OpenTelemetry Tracing and Observability
+
+Probe provides comprehensive monitoring and observability features for AI interactions:
+
+- **Performance Monitoring**: Track AI response times, token usage, and throughput
+- **File-based Tracing**: Save traces to JSON Lines format for offline analysis
+- **Remote Tracing**: Send traces to OpenTelemetry collectors (Jaeger, Zipkin, etc.)
+- **GitHub Actions Integration**: Automatic trace collection and artifact uploads
+- **Rich Telemetry Data**: Capture model details, session information, and error tracking
+- **Cost Optimization**: Monitor and analyze token consumption patterns
+
+```bash
+# Enable file-based tracing
+probe-chat --trace-file ./traces.jsonl
+
+# Enable remote tracing to Jaeger
+probe-chat --trace-remote http://localhost:4318/v1/traces
+
+# Enable console tracing for debugging
+probe-chat --trace-console
+```
+
+### Pattern Matching
+
+- **AST-Grep Patterns**: Search for specific code patterns using structural queries
+- **Tree-Sitter Queries**: Language-aware structural search
+- **Placeholder Variables**: Match function names, parameters, and bodies with variables
+- **Structure-Aware Matching**: Finds code based on its structure, not just text content
+
+### NPM Integration
+
+- **Global Installation**: Simple `npm install -g @probelabs/probe@latest` for system-wide access
+- **NPX Execution**: Run without installation via `npx -y @probelabs/probe-chat@latest`
+- **Node.js API**: Programmatic access via JavaScript
+- **Vercel AI SDK**: Streaming AI responses in web applications
+
+## Getting Started
+
+Ready to try Probe? Check out these resources:
+
+- [Installation](./installation.md): Get Probe set up on your system
+- [Quick Start](./quick-start.md): Learn the basics in minutes
+- [How It Works](./how-it-works.md): Understand the technology behind Probe
+
+## Use Cases
+
+Probe is designed for a variety of workflows:
+
+- **AI-Assisted Coding**: Provide your AI assistant with accurate code context
+- **Code Exploration**: Quickly find and understand code in large repositories
+- **Documentation Generation**: Extract code examples for documentation
+- **Code Review**: Find patterns and anti-patterns across your codebase
+- **Refactoring**: Identify all instances of a pattern that needs to be changed
+
+For more detailed information on specific features, see:
+- [How Probe Works](how-it-works.md)
+- [Search Functionality](search-functionality.md)
+- [Code Extraction](code-extraction.md)

package/data/probe/site/how-it-works.md

@@ -0,0 +1,118 @@
+# How Probe Works
+
+Probe combines efficient text search with code intelligence to find relevant code in your codebase.
+
+## System Architecture
+
+Probe operates in six stages:
+
+1. **Scan**: File identification using ripgrep
+2. **Parse**: Code structure analysis via Abstract Syntax Trees
+3. **Process**: Query enhancement with NLP techniques
+4. **Rank**: Result prioritization
+5. **Extract**: Code block isolation
+6. **Format**: Output generation
+
+## Search Workflow
+
+Here's how a search for "error handling" works:
+
+1. **Query Processing**:
+   - Tokenize → [error, handling]
+   - Stem → [error, handl]
+   - Generate patterns → `\berror\b`, `\bhandl\w*\b`
+   - Parse query syntax → AND(error, handling)
+
+2. **File Scanning**:
+   - Identify potential matches using ripgrep
+   - Filter based on .gitignore and custom patterns
+   - Exclude test files (unless specified otherwise)
+
+3. **Code Analysis**:
+   - Parse matching files into ASTs
+   - Identify complete code blocks containing matches
+   - Extract metadata (function names, parameters, etc.)
+
+4. **Result Ranking**:
+   - Calculate relevance scores
+   - Apply position weights for terms in identifiers
+   - Sort by combined relevance metrics
+   - Filter based on session cache (if enabled)
+
+5. **Block Extraction**:
+   - Extract complete functions/methods with matches
+   - Merge related code blocks when appropriate
+   - Apply context lines if requested
+
+6. **Result Delivery**:
+   - Format with syntax highlighting
+   - Apply token/size constraints
+   - Generate structured output
+
+## Rapid Scanning
+
+The foundation of Probe's speed:
+
+- **Ripgrep Engine**: Fast line scanning at core
+- **Parallel Processing**: Utilizes all CPU cores
+- **Smart Filtering**: Respects .gitignore patterns
+- **Stream Processing**: Minimal memory footprint
+- **Incremental Matching**: Stops scanning when limits are reached
+
+## Code Structure Parsing
+
+Where Probe becomes more than just text search:
+
+- **Tree-sitter**: Industry-standard parsing technology
+- **AST Generation**: Builds complete code structure map
+- **Language-specific**: Understands each language's unique patterns
+- **Robust Handling**: Works with partial or imperfect code
+- **Symbol Resolution**: Maps identifiers to declarations
+
+## Session-based Caching
+
+Avoiding duplicate results across multiple searches:
+
+- **Unique Identifiers**: Cache keys based on file path and line numbers
+- **Result Tracking**: Remembers which blocks have been shown
+- **Session Management**: Generates and maintains session IDs
+- **Cache Invalidation**: Clears cache when appropriate
+
+## Output Strategies
+
+Delivering results in the most useful format:
+
+- **Markdown/Syntax**: Rich, readable code presentation
+- **JSON**: Structured for programmatic use
+- **Token Limiting**: Fits within AI context windows
+- **Priority Handling**: Most relevant results survive limits
+- **Streaming**: Real-time output for interactive use
+
+## Integration Architecture
+
+How Probe connects with other tools:
+
+### MCP Server
+
+- **STDIO Transport**: Communicates via standard input/output
+- **JSON Protocol**: Structured message format
+- **Tool Definitions**: Exposes search, query, and extract capabilities
+
+### Node.js SDK
+
+- **JS Bindings**: JavaScript interface to core functionality
+- **Vercel AI SDK**: Integration for streaming AI responses
+- **Promise-based**: Async/await compatible API
+- **Type Definitions**: TypeScript support
+
+### Web Interface
+
+- **Express Backend**: Node.js server for API endpoints
+- **Vanilla JS Frontend**: No framework dependencies
+- **Streaming Responses**: Real-time AI output
+- **Markdown Rendering**: Rich text and code formatting
+
+For detailed information on specific features, see:
+- [Search Functionality](search-functionality.md)
+- [Code Extraction](code-extraction.md)
+- [Feature Overview](features.md)