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

package/data/probe/CLAUDE.md

@@ -0,0 +1,226 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with the probe codebase.
+
+**IMPORTANT**: ALWAYS use code-search-agent to navigate the codebase and ask questions about it.
+
+## Project Overview
+
+Probe is an AI-friendly, fully local, semantic code search tool built in Rust that combines ripgrep's speed with tree-sitter's AST parsing. It's designed to power AI coding assistants with precise, context-aware code search and extraction capabilities.
+
+## Development Guidelines
+
+### 1. Testing Requirements
+
+**EVERY feature, bug fix, or change MUST include tests:**
+- Unit tests for new functions/modules (in same file using `#[cfg(test)]`)
+- Integration tests for cross-module functionality (in `tests/` directory)
+- CLI tests for command-line interface changes (`tests/cli_tests.rs`)
+- Property-based tests with `proptest` for complex logic
+- Test coverage for edge cases and error conditions
+
+**Test patterns in this codebase:**
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_feature_name() {
+        // Arrange
+        let input = create_test_data();
+        
+        // Act
+        let result = function_under_test(input);
+        
+        // Assert
+        assert_eq!(result, expected_value);
+        assert!(condition);
+        assert_ne!(unexpected, actual);
+    }
+}
+```
+
+**Before committing:**
+```bash
+make test           # Run all tests (unit + integration + CLI)
+make test-unit      # Run unit tests only
+make test-cli       # Run CLI tests
+make test-property  # Run property-based tests
+```
+
+### 2. Error Handling
+
+**Always use proper error handling with anyhow:**
+```rust
+use anyhow::{Context, Result};
+
+// Good - use Result<T> with context
+pub fn parse_file(path: &Path) -> Result<ParsedData> {
+    let content = fs::read_to_string(path)
+        .context(format!("Failed to read file: {:?}", path))?;
+    
+    parse_content(&content)
+        .context("Failed to parse file content")
+}
+
+// Bad - using unwrap() in production code
+pub fn parse_file(path: &Path) -> ParsedData {
+    let content = fs::read_to_string(path).unwrap(); // NO!
+    parse_content(&content).unwrap() // NO!
+}
+```
+
+**Key patterns:**
+- Return `Result<T>` for all fallible operations
+- Use `.context()` to add error context
+- Use `anyhow::Error` for flexible error handling
+- Create custom error types when domain-specific errors needed
+- Never use `.unwrap()` except in tests
+
+### 3. Code Quality Standards
+
+**Before EVERY commit run these commands:**
+```bash
+make format         # Format code with rustfmt
+make lint           # Run clippy linter
+make test           # Run all tests
+# OR simply:
+make fix-all        # Runs format + lint fixes + tests
+```
+
+**Code organization principles:**
+- Keep modules focused and single-purpose
+- Use descriptive names (avoid abbreviations like `cfg`, `ctx`)
+- Add doc comments (`///`) for all public APIs
+- Keep functions under 50 lines when possible
+- Group related functionality in modules
+
+### 4. Performance Considerations
+
+- Profile before optimizing using `DEBUG=1` environment variable
+- Document performance-critical code with comments
+- Prefer lazy evaluation and iterators over collecting
+- Use `rayon` for CPU-bound parallel tasks
+- Leverage caching for expensive operations
+- See `docs/PERFORMANCE_OPTIMIZATION.md` for detailed methodology
+
+### 5. Adding New Features
+
+**Process for new features:**
+1. Search existing code for similar patterns using probe itself
+2. Write tests FIRST (TDD approach)
+3. Implement the feature
+4. Ensure all tests pass
+5. Update relevant documentation
+6. Run `make fix-all` before committing
+
+**For new language support:**
+1. Add tree-sitter parser to `Cargo.toml`
+2. Create module in `src/language/` implementing `Language` trait
+3. Add comprehensive tests including test detection
+4. Register in `src/language/factory.rs`
+5. Update docs in `site/supported-languages.md`
+
+## Common Commands
+
+```bash
+# Building
+make build              # Debug build
+cargo build --release   # Release build with optimizations
+
+# Testing & Quality
+make test              # All tests
+make test-unit         # Unit tests only
+make lint              # Run clippy
+make format            # Format code
+make fix-all           # Fix everything automatically
+
+# Running probe
+cargo run -- search "query" ./path
+cargo run -- extract file.rs:42
+probe search "function" ./src --max-results 10
+
+# Performance debugging
+DEBUG=1 probe search "query" ./path  # Shows timing information
+```
+
+## Architecture Quick Reference
+
+### Core Components
+- `src/language/` - Language parsers using tree-sitter
+- `src/search/` - Search engine with Elastic query support
+- `src/extract/` - Code extraction logic
+- `src/ranking.rs` - BM25 and TF-IDF ranking
+- `src/simd_ranking.rs` - SIMD-optimized ranking
+
+### Key Design Patterns
+- **Result<T> everywhere**: All fallible operations return Result
+- **Lazy evaluation**: Parse only what's needed
+- **Parallel processing**: Use rayon for file processing
+- **Caching**: Multiple cache levels (parser pool, tree cache, search cache)
+- **Zero-copy where possible**: Use references and slices
+
+## GitHub Integration
+
+**ALWAYS use `gh` CLI for GitHub operations:**
+```bash
+gh issue view <number> --comments    # View issue with full discussion
+gh pr view <number> --comments       # View PR with reviews
+gh pr create                         # Create pull request
+```
+
+## Project-Specific Patterns
+
+### Testing Patterns
+- Unit tests use `#[cfg(test)]` modules in same file
+- Integration tests go in `tests/` directory  
+- Use `assert!`, `assert_eq!`, `assert_ne!` macros
+- Property tests with `proptest` for fuzzing
+- Test both success and error cases
+
+### Module Organization
+```rust
+// Standard module layout
+pub mod module_name;              // Public module
+mod internal_module;              // Private module
+pub use module_name::PublicItem;  // Re-exports
+
+#[cfg(test)]
+mod tests {                       // Test module
+    use super::*;
+}
+```
+
+### Common Idioms
+- Use `Arc<>` for shared immutable data
+- Prefer `&str` over `String` for function parameters
+- Use `PathBuf` for owned paths, `&Path` for borrowed
+- Implement `Display` and `Debug` for public types
+- Use `#[derive()]` for common traits
+
+## Important Notes
+
+### NPM Package Management
+When adding files to `examples/chat/`, ALWAYS update the `files` array in `examples/chat/package.json`.
+
+### Pre-commit Hook
+The project has git hooks in `.githooks/`. Install with:
+```bash
+make install-hooks
+```
+
+### Debugging Tips
+- Use `DEBUG=1` for verbose output
+- Check `error.log` for detailed errors
+- Use `RUST_BACKTRACE=1` for stack traces
+- Profile with `cargo flamegraph` for performance
+
+## Getting Help
+
+1. Search codebase first: `probe search "topic" ./src`
+2. Check existing tests for usage examples
+3. Review similar implementations
+4. Consult docs in `site/` directory
+
+Remember: **Quality > Speed**. Write tests, handle errors properly, and maintain code standards.

package/data/probe/CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+email: leonsbox@gmail.com.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

package/data/probe/CONTRIBUTING.md

@@ -0,0 +1,193 @@
+# Contributing to Probe
+
+Thank you for considering contributing to Probe! This document provides guidelines and instructions to make the contribution process smooth and effective.
+
+## Table of Contents
+
+- [Code of Conduct](#code-of-conduct)
+- [Development Setup](#development-setup)
+- [Development Workflow](#development-workflow)
+- [Pull Request Process](#pull-request-process)
+- [Testing Guidelines](#testing-guidelines)
+- [Coding Standards](#coding-standards)
+- [Documentation](#documentation)
+- [Release Process](#release-process)
+
+## Code of Conduct
+
+By participating in this project, you are expected to uphold our Code of Conduct. Please report unacceptable behavior to the project maintainers.
+
+## Development Setup
+
+### Prerequisites
+
+- Rust and Cargo (latest stable version)
+- Git
+- Make (for using the Makefile commands)
+
+### Getting Started
+
+1. Fork the repository on GitHub
+2. Clone your fork locally:
+   ```bash
+   git clone https://github.com/YOUR-USERNAME/probe.git
+   cd probe
+   ```
+3. Set up the git hooks to ensure code quality:
+   ```bash
+   make install-hooks
+   ```
+4. Add the original repository as a remote to keep your fork updated:
+   ```bash
+   git remote add upstream https://github.com/probelabs/probe.git
+   ```
+
+### Building the Project
+
+To build the project in debug mode:
+```bash
+make build
+```
+
+To run the application:
+```bash
+make run
+```
+
+For a release build:
+```bash
+make run-release
+```
+
+## Development Workflow
+
+1. Create a new branch for your feature or bugfix:
+   ```bash
+   git checkout -b feature/your-feature-name
+   ```
+   or
+   ```bash
+   git checkout -b fix/issue-you-are-fixing
+   ```
+
+2. Make your changes, following the [Coding Standards](#coding-standards)
+
+3. Run tests to ensure your changes don't break existing functionality:
+   ```bash
+   make test
+   ```
+
+4. Format your code:
+   ```bash
+   make format
+   ```
+
+5. Run the linter:
+   ```bash
+   make lint
+   ```
+
+6. Commit your changes using the [Git Commit Message Guidelines](#git-commit-message-guidelines)
+
+7. Push your branch to your fork:
+   ```bash
+   git push origin feature/your-feature-name
+   ```
+
+8. Create a Pull Request from your fork to the main repository
+
+## Pull Request Process
+
+1. Ensure your PR includes a clear description of the changes and the purpose
+2. Link any related issues using keywords like "Fixes #123" or "Resolves #456"
+3. Make sure all tests pass and there are no linting errors
+4. Add tests for new functionality
+5. Update documentation as needed
+6. Your PR will be reviewed by maintainers who may request changes
+7. Once approved, your PR will be merged
+
+## Testing Guidelines
+
+Probe uses several types of tests to ensure quality:
+
+### Running Tests
+
+- Run all tests:
+  ```bash
+  make test
+  ```
+
+- Run specific test types:
+  ```bash
+  make test-unit          # Unit tests
+  make test-integration   # Integration tests
+  make test-property      # Property-based tests
+  make test-cli           # CLI tests
+  ```
+
+### Writing Tests
+
+- **Unit Tests**: Place in the same file as the code being tested, using Rust's `#[cfg(test)]` module
+- **Integration Tests**: Add to the `tests/` directory
+- **Property Tests**: Use the proptest framework for property-based testing
+- **CLI Tests**: Test the command-line interface functionality
+
+## Coding Standards
+
+### Rust Style Guidelines
+
+- Follow the [Rust API Guidelines](https://rust-lang.github.io/api-guidelines/)
+- Use `rustfmt` for consistent formatting (run `make format`)
+- Use `clippy` to catch common mistakes (run `make lint`)
+
+### Git Commit Message Guidelines
+
+- Use the present tense ("Add feature" not "Added feature")
+- Use the imperative mood ("Move cursor to..." not "Moves cursor to...")
+- Limit the first line to 72 characters or less
+- Reference issues and pull requests after the first line
+- Consider using emoji prefixes for better readability:
+  - 🎨 `:art:` when improving code structure/format
+  - 🐎 `:racehorse:` when improving performance
+  - 📝 `:memo:` when writing docs
+  - 🐛 `:bug:` when fixing a bug
+  - ✅ `:white_check_mark:` when adding tests
+  - 🔒 `:lock:` when dealing with security
+
+## Documentation
+
+- Update the README.md if you change functionality
+- Document all public API items with rustdoc comments
+- Include examples in documentation where appropriate
+- Generate documentation with:
+  ```bash
+  make doc
+  ```
+
+## Adding Support for New Languages
+
+If you want to add support for a new programming language:
+
+1. Add the appropriate tree-sitter grammar dependency to `Cargo.toml`
+2. Implement the language parser in the `src/language` directory
+3. Update the language detection logic
+4. Add tests for the new language support
+5. Update the documentation to include the new supported language
+
+## Release Process
+
+Releases are managed by the project maintainers. The process involves:
+
+1. Updating the version in `Cargo.toml`
+2. Building release packages for all supported platforms:
+   ```bash
+   VERSION=vX.Y.Z make release
+   ```
+3. Creating a new GitHub release with release notes
+4. Publishing the updated package
+
+## Questions?
+
+If you have any questions about contributing, feel free to open an issue or contact the project maintainers.
+
+Thank you for contributing to Probe!

package/data/probe/Cargo.toml

@@ -0,0 +1,120 @@
+[package]
+name = "probe-code"
+version = "0.6.0"
+edition = "2021"
+rust-version = "1.88.0"
+authors = ["Leonid Bugaev <leonsbox@gmail.com>"]
+description = "AI-friendly, fully local, semantic code search tool for large codebases"
+license = "MIT"
+repository = "https://github.com/probelabs/probe"
+readme = "README.md"
+keywords = ["search", "code", "ast", "grep", "semantic"]
+categories = ["command-line-utilities", "development-tools", "text-processing"]
+
+[lints.clippy]
+# Allow uninlined format args for existing code - will be addressed in future cleanup
+uninlined_format_args = "allow"
+
+[dependencies]
+ahash = "0.8.6"  # Fast, non-cryptographic hash function
+dashmap = "5.5.3"  # Thread-safe concurrent HashMap
+anyhow = "1.0"
+atty = "0.2.13"
+colored = "3.0.0"
+dirs = "5.0.1"
+ignore = "0.4"
+tree-sitter = "0.24.5"
+tree-sitter-rust = "0.23.2"
+tree-sitter-javascript = "0.23.1"
+tree-sitter-typescript = "0.23.2"
+tree-sitter-python = "0.23.6"
+tree-sitter-go = "0.23.4"
+tree-sitter-c = "0.23.4"
+tree-sitter-cpp = "0.23.4"
+tree-sitter-java = "0.23.5"
+tree-sitter-ruby = "0.23.1"
+tree-sitter-php = "0.23.11"
+tree-sitter-swift = { version = "0.7.0" }
+tree-sitter-c-sharp = { version = "0.23.1" }
+tree-sitter-html = "0.23.2"
+tree-sitter-md = "0.3.2"
+tree-sitter-yaml = "0.6.1"
+ast-grep-core = "0.36.1"
+ast-grep-language = "0.36.1"
+clap = { version = "4.3", features = ["derive"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+rust-stemmers = "1.2"
+tokio = { version = "1", features = ["full"] }
+tiktoken-rs = "0.6.0"
+regex = "1.9"
+rayon = "1.8"
+once_cell = "1.19.0"
+decompound = "0.3.0"
+lazy_static = "1.4.0"
+rand = "0.8.5"
+glob = "0.3.1"
+arboard = "3.4.1"
+md5 = "0.7.0"
+lru = "0.12.5"
+simsimd = "6.1.0"  # SIMD-accelerated similarity metrics for vector operations
+memchr = "2.7"  # SIMD-accelerated string searching and processing
+aho-corasick = "1.1"  # SIMD-accelerated multi-pattern string matching
+num_cpus = "1.16"  # Detect number of CPUs for parallel processing
+# BERT reranker dependencies - optional for ms-marco-tinybert reranker
+candle-core = { version = "0.8", optional = true }
+candle-nn = { version = "0.8", optional = true }
+candle-transformers = { version = "0.8", optional = true }
+tokenizers = { version = "0.20", optional = true }
+hf-hub = { version = "0.3", features = ["tokio"], optional = true }
+parking_lot = { version = "0.12", optional = true }
+
+[dev-dependencies]
+tempfile = "3.10.1"
+proptest = "1.2"
+criterion = "0.5"
+roxmltree = "0.18.0"
+jsonschema = "0.17.1"
+
+[lib]
+name = "probe_code"
+path = "src/lib.rs"
+
+[[bin]]
+name = "probe"
+path = "src/main.rs"
+
+[features]
+default = []
+bert-reranker = [
+    "candle-core",
+    "candle-nn", 
+    "candle-transformers",
+    "tokenizers",
+    "hf-hub",
+    "parking_lot"
+]
+
+
+[[bench]]
+name = "search_benchmarks"
+harness = false
+
+[[bench]]
+name = "timing_benchmarks"
+harness = false
+
+[[bench]]
+name = "parsing_benchmarks"
+harness = false
+
+[[bench]]
+name = "simd_benchmarks"
+harness = false
+
+[profile.release]
+opt-level = "z"  # Optimize for size ("s" also works, but "z" is smaller)
+strip = true     # Strip symbols automatically
+lto = true       # Link-time optimization
+codegen-units = 1 # Slower compile, smaller binary
+panic = "abort"  # Ditch unwinding code

package/data/probe/Cross.toml

@@ -0,0 +1,10 @@
+# Cross-compilation configuration for probe
+# This configures the cross tool for ARM64 Linux builds
+
+[build.env]
+passthrough = [
+    "CARGO_INCREMENTAL",
+    "CARGO_TERM_COLOR",
+]
+
+# Cross uses prebuilt images for musl targets; no per-target overrides needed.