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

package/data/probe/tests/extract_deduplication_tests.rs

@@ -0,0 +1,146 @@
+use std::fs;
+use std::process::Command;
+
+use probe_code::extract::{handle_extract, ExtractOptions};
+
+#[test]
+fn test_deduplication_of_nested_extractions() {
+    // Create a temporary file with nested structures for testing
+    let temp_dir = tempfile::tempdir().unwrap();
+    let file_path = temp_dir.path().join("nested_test.rs");
+    let content = r#"
+fn outer_function() {
+    let x = 10;
+
+    // This is a nested function that should be deduplicated
+    fn inner_function() {
+        let y = 20;
+        println!("Inner function: {}", y);
+    }
+
+    // Call the inner function
+    inner_function();
+    println!("Outer function: {}", x);
+}
+
+fn standalone_function() {
+    println!("This is standalone");
+}
+"#;
+    fs::write(&file_path, content).unwrap();
+
+    // Enable debug mode to see deduplication logs
+    std::env::set_var("DEBUG", "1");
+
+    // Create options with both the outer function and inner function
+    let options = ExtractOptions {
+        files: vec![
+            format!("{}:2", file_path.to_string_lossy()), // outer function
+            format!("{}:6", file_path.to_string_lossy()), // inner function (should be deduplicated)
+            format!("{}:16", file_path.to_string_lossy()), // standalone function
+        ],
+        custom_ignores: vec![],
+        context_lines: 0,
+        format: "plain".to_string(),
+        from_clipboard: false,
+        input_file: None,
+        to_clipboard: false,
+        dry_run: true, // Use dry run to avoid actual output
+        diff: false,
+        allow_tests: true,
+        keep_input: false,
+        prompt: None,
+        instructions: None,
+        no_gitignore: false,
+    };
+
+    // Call handle_extract
+    handle_extract(options).unwrap();
+
+    // Clean up environment variable
+    std::env::remove_var("DEBUG");
+
+    // The test passes if it runs without panicking
+    // The actual verification is done by manual inspection of the debug output
+    // which will show the nested duplicate being removed
+}
+
+#[test]
+fn test_deduplication_with_command_line_integration() {
+    // Create a temporary file with nested structures for testing
+    let temp_dir = tempfile::tempdir().unwrap();
+    let file_path = temp_dir.path().join("nested_test.rs");
+    let content = r#"
+fn outer_function() {
+    let x = 10;
+
+    // This is a nested function that should be deduplicated
+    fn inner_function() {
+        let y = 20;
+        println!("Inner function: {}", y);
+    }
+
+    // Call the inner function
+    inner_function();
+    println!("Outer function: {}", x);
+}
+
+fn standalone_function() {
+    println!("This is standalone");
+}
+"#;
+    fs::write(&file_path, content).unwrap();
+
+    // Get the project root directory (where Cargo.toml is)
+    let project_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+
+    // Run the extract command with both the outer function and inner function
+    let output = Command::new("cargo")
+        .args([
+            "run",
+            "--manifest-path",
+            project_dir.join("Cargo.toml").to_string_lossy().as_ref(),
+            "--",
+            "extract",
+            &format!("{}:2", file_path.to_string_lossy()), // outer function
+            &format!("{}:6", file_path.to_string_lossy()), // inner function (should be deduplicated)
+            "--allow-tests",
+            "--format",
+            "json",
+        ])
+        .env("DEBUG", "1")
+        .output()
+        .expect("Failed to execute command");
+
+    // Check that the command executed successfully
+    assert!(output.status.success(), "Command failed to execute");
+
+    // Get the output as a string
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    // Print the output for debugging
+    println!("Command stdout: {stdout}");
+    println!("Command stderr: {stderr}");
+
+    // Check for deduplication logs in stdout (not stderr)
+    assert!(
+        stdout.contains("Before deduplication:") && stdout.contains("After deduplication:"),
+        "Deduplication logs not found in output"
+    );
+
+    // The deduplication is working correctly, as we can see in the logs
+    // Let's verify that the output contains only one result
+
+    // Check that the output contains the outer function but not the inner function as a separate result
+    assert!(
+        stdout.contains("\"count\": 1"),
+        "Should only have one result after deduplication"
+    );
+    assert!(
+        stdout.contains("outer_function"),
+        "Output should contain the outer function"
+    );
+
+    // Success! The deduplication is working correctly
+}

package/data/probe/tests/extract_input_file_tests.rs

@@ -0,0 +1,84 @@
+use std::fs;
+use std::process::Command;
+use tempfile::TempDir;
+
+#[test]
+fn test_extract_command_with_input_file() {
+    // Create a temporary directory for our test files
+    let temp_dir = TempDir::new().expect("Failed to create temp dir");
+
+    // Create a test source file with simple content
+    let source_file_path = temp_dir.path().join("test_source.rs");
+    let source_content = r#"
+fn main() {
+    println!("Hello, world!");
+}
+"#;
+    fs::write(&source_file_path, source_content).unwrap();
+
+    // Create an input file that contains the path to the source file
+    let input_file_path = temp_dir.path().join("input.txt");
+    fs::write(
+        &input_file_path,
+        source_file_path.to_string_lossy().as_bytes(),
+    )
+    .unwrap();
+
+    // Get the project root directory (where Cargo.toml is)
+    let project_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+
+    // Run the extract command with --help to verify the new option exists
+    let help_output = Command::new("cargo")
+        .args([
+            "run",
+            "--manifest-path",
+            project_dir.join("Cargo.toml").to_string_lossy().as_ref(),
+            "--",
+            "extract",
+            "--help",
+        ])
+        .output()
+        .expect("Failed to execute help command");
+
+    // Check that the help output includes the new option
+    let help_text = String::from_utf8_lossy(&help_output.stdout);
+    assert!(
+        help_text.contains("-F, --input-file"),
+        "Help text should include the new --input-file option"
+    );
+}
+
+#[test]
+fn test_extract_command_with_nonexistent_input_file() {
+    // Get the project root directory (where Cargo.toml is)
+    let project_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+
+    // Run the extract command with a nonexistent input file
+    let output = Command::new("cargo")
+        .args([
+            "run",
+            "--manifest-path",
+            project_dir.join("Cargo.toml").to_string_lossy().as_ref(),
+            "--",
+            "extract",
+            "--input-file",
+            "nonexistent_file.txt",
+        ])
+        .output()
+        .expect("Failed to execute command");
+
+    // The command should fail
+    assert!(
+        !output.status.success(),
+        "Command should fail with nonexistent file"
+    );
+
+    // Get the error output as a string
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    // The error should mention the nonexistent file
+    assert!(
+        stderr.contains("nonexistent_file.txt"),
+        "Error should mention the nonexistent file"
+    );
+}

package/data/probe/tests/extract_prompt_tests.rs

@@ -0,0 +1,102 @@
+use std::fs;
+use std::process::Command;
+
+#[test]
+fn test_extract_with_prompt_and_instructions() {
+    // Create a temporary file for testing
+    let temp_dir = tempfile::tempdir().unwrap();
+    let file_path = temp_dir.path().join("test_file.rs");
+    let content = r#"
+fn test() {
+    println!("Hello, world!");
+}
+"#;
+    fs::write(&file_path, content).unwrap();
+
+    // Get the project root directory (where Cargo.toml is)
+    let project_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+
+    // Run the extract command with prompt and instructions
+    let output = Command::new("cargo")
+        .args([
+            "run",
+            "--manifest-path",
+            project_dir.join("Cargo.toml").to_string_lossy().as_ref(),
+            "--",
+            "extract",
+            file_path.to_string_lossy().as_ref(),
+            "--format",
+            "json",
+            "--prompt",
+            "engineer",
+            "--instructions",
+            "Explain what this function does",
+            "--allow-tests", // Add this flag to ensure test files are included
+        ])
+        .output()
+        .expect("Failed to execute command");
+
+    // Check that the command executed successfully
+    assert!(output.status.success(), "Command failed to execute");
+
+    // Get the output as a string
+    let stdout = String::from_utf8_lossy(&output.stdout);
+
+    // Helper function to extract JSON from command output
+    fn extract_json_from_output(output: &str) -> &str {
+        // Find the first occurrence of '{'
+        if let Some(start_index) = output.find('{') {
+            // Return the substring from the first '{' to the end
+            &output[start_index..]
+        } else {
+            // If no '{' is found, return the original string
+            output
+        }
+    }
+
+    // Extract and parse the JSON
+    let json_str = extract_json_from_output(&stdout);
+    let json_value: serde_json::Value =
+        serde_json::from_str(json_str).expect("Failed to parse JSON output");
+
+    // Validate the structure of the JSON output
+    assert!(json_value.is_object(), "JSON output should be an object");
+    assert!(
+        json_value.get("results").is_some(),
+        "JSON output should have a 'results' field"
+    );
+
+    // Validate the results array
+    let results = json_value.get("results").unwrap().as_array().unwrap();
+    assert!(!results.is_empty(), "Results array should not be empty");
+
+    // Check for system_prompt field at the top level
+    assert!(
+        json_value.get("system_prompt").is_some(),
+        "JSON output should have a 'system_prompt' field"
+    );
+    let system_prompt = json_value.get("system_prompt").unwrap().as_str().unwrap();
+    assert!(
+        system_prompt.contains("senior software engineer"),
+        "System prompt should contain the engineer template"
+    );
+
+    // Check for user_instructions field at the top level
+    assert!(
+        json_value.get("user_instructions").is_some(),
+        "JSON output should have a 'user_instructions' field"
+    );
+    let user_instructions = json_value
+        .get("user_instructions")
+        .unwrap()
+        .as_str()
+        .unwrap();
+    assert_eq!(
+        user_instructions, "Explain what this function does",
+        "User instructions should match the input"
+    );
+    assert_eq!(
+        user_instructions, "Explain what this function does",
+        "User instructions should match the input"
+    );
+}

package/data/probe/tests/filename_search_tests.rs

@@ -0,0 +1,96 @@
+use probe_code::search::elastic_query;
+use probe_code::search::filters::SearchFilters;
+use std::path::PathBuf;
+
+#[test]
+fn test_filename_directive_extraction() {
+    // Test explicit filename: directive
+    let query = "filename:\"SWE_TASK.txt\"";
+    let ast = elastic_query::parse_query(query, false).expect("Failed to parse query");
+    let (filters, simplified_ast) = SearchFilters::extract_and_simplify_with_autodetect(ast);
+
+    // Check that filename filter was extracted
+    assert_eq!(filters.exact_filenames.len(), 1);
+    assert_eq!(filters.exact_filenames[0], "SWE_TASK.txt");
+
+    // Should have no content search since only filename was specified
+    assert!(simplified_ast.is_none());
+
+    // Test that the filter matches the file
+    assert!(filters.matches_file(&PathBuf::from("SWE_TASK.txt")));
+    assert!(filters.matches_file(&PathBuf::from("path/to/SWE_TASK.txt")));
+    assert!(!filters.matches_file(&PathBuf::from("OTHER_FILE.txt")));
+}
+
+#[test]
+fn test_filename_auto_detection() {
+    // Test auto-detection of filename-like terms
+    let query = "\"config.json\"";
+    let ast = elastic_query::parse_query(query, false).expect("Failed to parse query");
+    let (filters, simplified_ast) = SearchFilters::extract_and_simplify_with_autodetect(ast);
+
+    // Should auto-detect as filename
+    assert_eq!(filters.exact_filenames.len(), 1);
+    assert_eq!(filters.exact_filenames[0], "config.json");
+    assert!(simplified_ast.is_none());
+
+    // Test that the filter works
+    assert!(filters.matches_file(&PathBuf::from("config.json")));
+    assert!(filters.matches_file(&PathBuf::from("src/config.json")));
+    assert!(!filters.matches_file(&PathBuf::from("data.xml")));
+}
+
+#[test]
+fn test_filename_or_query() {
+    // Test OR query with multiple filenames
+    let query = "\"SWE_TASK.txt\" OR \"swebench_problem.json\"";
+    let ast = elastic_query::parse_query(query, false).expect("Failed to parse query");
+    let (filters, simplified_ast) = SearchFilters::extract_and_simplify_with_autodetect(ast);
+
+    // Both should be detected as filenames
+    assert_eq!(filters.exact_filenames.len(), 2);
+    assert!(filters
+        .exact_filenames
+        .contains(&"SWE_TASK.txt".to_string()));
+    assert!(filters
+        .exact_filenames
+        .contains(&"swebench_problem.json".to_string()));
+    assert!(simplified_ast.is_none());
+
+    // Test that filters match both files
+    assert!(filters.matches_file(&PathBuf::from("SWE_TASK.txt")));
+    assert!(filters.matches_file(&PathBuf::from("swebench_problem.json")));
+    assert!(!filters.matches_file(&PathBuf::from("other.md")));
+}
+
+#[test]
+fn test_filename_and_content_query() {
+    // Test AND query with filename and content search
+    let query = "\"task.txt\" AND error";
+    let ast = elastic_query::parse_query(query, false).expect("Failed to parse query");
+    let (filters, simplified_ast) = SearchFilters::extract_and_simplify_with_autodetect(ast);
+
+    // Filename should be extracted as filter
+    assert_eq!(filters.exact_filenames.len(), 1);
+    assert_eq!(filters.exact_filenames[0], "task.txt");
+
+    // "error" should remain in AST for content search
+    assert!(simplified_ast.is_some());
+
+    // Test filter matching
+    assert!(filters.matches_file(&PathBuf::from("task.txt")));
+    assert!(!filters.matches_file(&PathBuf::from("notes.txt")));
+}
+
+#[test]
+fn test_filename_case_insensitive() {
+    // Test case-insensitive filename matching
+    let query = "filename:\"readme.md\"";
+    let ast = elastic_query::parse_query(query, false).expect("Failed to parse query");
+    let (filters, _) = SearchFilters::extract_and_simplify_with_autodetect(ast);
+
+    // Should match regardless of case
+    assert!(filters.matches_file(&PathBuf::from("README.md")));
+    assert!(filters.matches_file(&PathBuf::from("readme.md")));
+    assert!(filters.matches_file(&PathBuf::from("Readme.MD")));
+}

package/data/probe/tests/fixtures/user/AssemblyInfo.cs

@@ -0,0 +1,3 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+[assembly: System.Resources.NeutralResourcesLanguage("en-US")]

package/data/probe/tests/github_extract_tests.rs

@@ -0,0 +1,234 @@
+use std::fs;
+use std::process::Command;
+use tempfile::TempDir;
+
+/// Integration tests specifically for the GitHub files extract bug fix.
+///
+/// This tests the issue where `probe extract` was incorrectly ignoring files
+/// in .github directories due to substring matching on ".git".
+
+#[test]
+fn test_extract_github_workflow_file() {
+    let temp_dir = TempDir::new().unwrap();
+
+    // Create .github directory structure
+    let github_dir = temp_dir.path().join(".github");
+    let workflows_dir = github_dir.join("workflows");
+    fs::create_dir_all(&workflows_dir).unwrap();
+
+    // Create a GitHub workflow file
+    let workflow_file = workflows_dir.join("ci.yml");
+    let workflow_content = r#"name: CI Pipeline
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Run tests
+      run: |
+        echo "Running tests"
+        cargo test --all
+
+    - name: Check formatting
+      run: cargo fmt --check
+
+  build:
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Build
+      run: cargo build --release
+"#;
+    fs::write(&workflow_file, workflow_content).unwrap();
+
+    // Test extracting the entire file
+    let output = Command::new(env!("CARGO_BIN_EXE_probe"))
+        .args(["extract", &workflow_file.to_string_lossy()])
+        .current_dir(temp_dir.path())
+        .output()
+        .expect("Failed to execute probe extract");
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    assert!(
+        output.status.success(),
+        "probe extract should succeed for .github files. stderr: {stderr}"
+    );
+    assert!(
+        stdout.contains("CI Pipeline"),
+        "Should extract content from GitHub workflow file. stdout: {stdout}"
+    );
+    assert!(
+        !stdout.contains("No results found"),
+        "Should not return 'No results found' for .github files"
+    );
+}
+
+#[test]
+fn test_extract_github_workflow_with_line_range() {
+    let temp_dir = TempDir::new().unwrap();
+
+    // Create .github directory structure
+    let github_dir = temp_dir.path().join(".github");
+    let workflows_dir = github_dir.join("workflows");
+    fs::create_dir_all(&workflows_dir).unwrap();
+
+    // Create a GitHub workflow file
+    let workflow_file = workflows_dir.join("test.yml");
+    let workflow_content = r#"name: Test Workflow
+on: [push]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+    - name: Test
+      run: echo "testing"
+"#;
+    fs::write(&workflow_file, workflow_content).unwrap();
+
+    // Test extracting specific lines (lines 3-7)
+    let file_with_range = format!("{}:3-7", workflow_file.to_string_lossy());
+    let output = Command::new(env!("CARGO_BIN_EXE_probe"))
+        .args(["extract", &file_with_range])
+        .current_dir(temp_dir.path())
+        .output()
+        .expect("Failed to execute probe extract with line range");
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    assert!(
+        output.status.success(),
+        "probe extract should succeed for .github files with line ranges. stderr: {stderr}"
+    );
+    assert!(
+        stdout.contains("jobs:"),
+        "Should extract the specified line range. stdout: {stdout}"
+    );
+    assert!(
+        stdout.contains("Lines: 3-7"),
+        "Should show the correct line range in output. stdout: {stdout}"
+    );
+}
+
+#[test]
+fn test_git_directory_still_ignored() {
+    let temp_dir = TempDir::new().unwrap();
+
+    // Create a .git directory (should be ignored)
+    let git_dir = temp_dir.path().join(".git");
+    fs::create_dir_all(&git_dir).unwrap();
+    let git_config = git_dir.join("config");
+    fs::write(&git_config, "[core]\n    repositoryformatversion = 0\n").unwrap();
+
+    // Test that .git files are still ignored
+    let output = Command::new(env!("CARGO_BIN_EXE_probe"))
+        .args(["extract", &git_config.to_string_lossy()])
+        .current_dir(temp_dir.path())
+        .output()
+        .expect("Failed to execute probe extract");
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+
+    // .git files should still be ignored (should return "No results found")
+    assert!(
+        stdout.contains("No results found"),
+        ".git directory files should still be ignored. stdout: {stdout}"
+    );
+}
+
+#[test]
+fn test_gitignore_file_not_ignored() {
+    let temp_dir = TempDir::new().unwrap();
+
+    // Create a .gitignore file (should NOT be ignored)
+    let gitignore_file = temp_dir.path().join(".gitignore");
+    fs::write(&gitignore_file, "*.log\ntmp/\n*.tmp\n").unwrap();
+
+    // Test that .gitignore files are NOT ignored
+    let output = Command::new(env!("CARGO_BIN_EXE_probe"))
+        .args(["extract", &gitignore_file.to_string_lossy()])
+        .current_dir(temp_dir.path())
+        .output()
+        .expect("Failed to execute probe extract");
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    assert!(
+        output.status.success(),
+        "probe extract should succeed for .gitignore files. stderr: {stderr}"
+    );
+    assert!(
+        stdout.contains("*.log"),
+        "Should extract content from .gitignore file. stdout: {stdout}"
+    );
+    assert!(
+        !stdout.contains("No results found"),
+        "Should not return 'No results found' for .gitignore files"
+    );
+}
+
+#[test]
+fn test_github_issue_template() {
+    let temp_dir = TempDir::new().unwrap();
+
+    // Create .github directory structure
+    let github_dir = temp_dir.path().join(".github");
+    fs::create_dir_all(&github_dir).unwrap();
+
+    // Create a GitHub issue template
+    let issue_template = github_dir.join("issue_template.md");
+    let template_content = r#"---
+name: Bug report
+about: Create a report to help us improve
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+"#;
+    fs::write(&issue_template, template_content).unwrap();
+
+    // Test extracting the issue template
+    let output = Command::new(env!("CARGO_BIN_EXE_probe"))
+        .args(["extract", &issue_template.to_string_lossy()])
+        .current_dir(temp_dir.path())
+        .output()
+        .expect("Failed to execute probe extract");
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    assert!(
+        output.status.success(),
+        "probe extract should succeed for .github issue templates. stderr: {stderr}"
+    );
+    assert!(
+        stdout.contains("Bug report"),
+        "Should extract content from GitHub issue template. stdout: {stdout}"
+    );
+    assert!(
+        stdout.contains("Describe the bug"),
+        "Should extract the issue template content. stdout: {stdout}"
+    );
+}