symforge 11.22.4

SymForge — in-memory code intelligence MCP server for Claude Code, Codex, and Gemini CLI
Documentation
#![cfg(feature = "embed")]

#[test]
fn search_token_caps_keep_full_shared_result_in_session_cache() {
    let root = tempfile::tempdir().unwrap();
    let source = (0..24)
        .map(|i| format!("pub fn selected_{i}() {{}}\n"))
        .collect::<String>();
    std::fs::write(root.path().join("lib.rs"), source).unwrap();
    let runtime = ProcessIndexRuntime::acquire().unwrap();
    let handle = open(&runtime, root.path());
    let session = handle.new_query_session().unwrap();
    let result = handle
        .query_with_session(
            &QueryRequest::SymbolSearch(SymbolSearchRequest {
                query: Some("selected".into()),
                limit: Some(24),
                max_tokens: Some(120),
                ..Default::default()
            }),
            QueryLimits::default(),
            &session,
            None,
        )
        .unwrap();
    assert!(result.truncated());
    let full = handle
        .query_with_session(
            &QueryRequest::Retrieve {
                handle: result.retrieve_handle().unwrap().into(),
                offset: 0,
            },
            QueryLimits::default(),
            &session,
            None,
        )
        .unwrap();
    let QueryOutput::RetrievedOutput(full) = full.value() else {
        panic!("full search cache");
    };
    let output: serde_json::Value = serde_json::from_slice(&full.bytes).unwrap();
    assert_eq!(
        output["output"]["SymbolSearch"]["symbols"]
            .as_array()
            .unwrap()
            .len(),
        24
    );
}

use std::fs;
use std::time::{Duration, Instant};
use symforge::embed::parity::search::{
    SymbolSearchRequest, TextGrouping, TextRows, TextSearchRequest,
};
use symforge::embed::parity::{QueryLimits, QueryOutput, QueryRefusalKind, QueryRequest};
use symforge::embed::{
    EmbeddedSourceHandle, EmbeddedSourceSpec, ProcessIndexRuntime, SourceRuntimePhase,
};

fn fixture() -> tempfile::TempDir {
    let root = tempfile::tempdir().unwrap();
    git2::Repository::init(root.path()).unwrap();
    fs::create_dir(root.path().join("src")).unwrap();
    fs::create_dir(root.path().join("tests")).unwrap();
    fs::write(root.path().join("src/lib.rs"), b"pub fn target() -> u32 {\n    let color = 1;\n    let colorful = 2;\n    color + colorful\n}\npub fn caller() -> u32 { target() }\n// color comment\n").unwrap();
    fs::write(
        root.path().join("src/omit.rs"),
        b"pub fn omitted() { let color = 1; }\n",
    )
    .unwrap();
    fs::write(
        root.path().join("src/other.py"),
        b"def python_color():\n    color = 1\n",
    )
    .unwrap();
    fs::write(
        root.path().join("tests/check.rs"),
        b"fn check() { let color = 1; }\n",
    )
    .unwrap();
    root
}
fn open(runtime: &ProcessIndexRuntime, root: &std::path::Path) -> EmbeddedSourceHandle {
    let handle = runtime
        .open_embedded_source(EmbeddedSourceSpec::current_worktree(root.to_path_buf()))
        .unwrap();
    let deadline = Instant::now() + Duration::from_secs(20);
    while handle.runtime_view().phase != SourceRuntimePhase::Current {
        assert!(Instant::now() < deadline);
        std::thread::sleep(Duration::from_millis(5));
    }
    handle
}
fn text(
    handle: &EmbeddedSourceHandle,
    request: TextSearchRequest,
) -> symforge::embed::parity::QueryClaim {
    handle
        .query(&QueryRequest::TextSearch(request), QueryLimits::default())
        .unwrap()
}

#[test]
fn rich_text_search_applies_terms_scope_globs_words_and_limits_before_projection() {
    let root = fixture();
    let runtime = ProcessIndexRuntime::acquire().unwrap();
    let handle = open(&runtime, root.path());
    let claim = text(
        &handle,
        TextSearchRequest {
            terms: Some(vec!["color".into(), "caller".into()]),
            whole_word: Some(true),
            language: Some("Rust".into()),
            glob: Some("**/*.rs".into()),
            exclude_glob: Some("**/omit.rs".into()),
            max_per_file: Some(20),
            limit: Some(20),
            ..Default::default()
        },
    );
    let QueryOutput::TextSearch(report) = claim.value() else {
        panic!()
    };
    let TextRows::Files(files) = &report.rows else {
        panic!()
    };
    assert_eq!(files.len(), 1);
    assert_eq!(files[0].path, "src/lib.rs");
    assert!(files[0].matches.iter().all(|hit| hit.line != 3));
    assert!(files[0].matches.iter().any(|hit| {
        hit.enclosing_symbol
            .as_ref()
            .is_some_and(|symbol| symbol.name == "caller")
    }));
    assert!(report.suppressed_by_noise > 0);
    let included = text(
        &handle,
        TextSearchRequest {
            query: Some("color".into()),
            include_tests: Some(true),
            path_prefix: Some("tests/".into()),
            ..Default::default()
        },
    );
    let QueryOutput::TextSearch(report) = included.value() else {
        panic!()
    };
    let TextRows::Files(files) = &report.rows else {
        panic!()
    };
    assert_eq!(files[0].path, "tests/check.rs");
}

#[test]
fn rich_text_search_preserves_regex_recovery_ast_context_callers_and_grouping() {
    let root = fixture();
    let runtime = ProcessIndexRuntime::acquire().unwrap();
    let handle = open(&runtime, root.path());
    let found = text(
        &handle,
        TextSearchRequest {
            query: Some(r"let\\s+color\\s*=".into()),
            regex: Some(true),
            path_prefix: Some("src/lib.rs".into()),
            max_per_file: Some(20),
            context: Some(1),
            follow_refs: Some(true),
            ..Default::default()
        },
    );
    let QueryOutput::TextSearch(report) = found.value() else {
        panic!()
    };
    assert!(report.auto_corrected_regex && report.regex);
    let TextRows::Files(files) = &report.rows else {
        panic!()
    };
    assert!(files[0].context.as_ref().unwrap().len() >= 3);
    assert!(
        files[0]
            .callers
            .as_ref()
            .unwrap()
            .iter()
            .any(|caller| caller.symbol == "caller")
    );
    let names = text(
        &handle,
        TextSearchRequest {
            query: Some("color".into()),
            path_prefix: Some("src/lib.rs".into()),
            group_by: Some(TextGrouping::Names),
            ..Default::default()
        },
    );
    let QueryOutput::TextSearch(report) = names.value() else {
        panic!()
    };
    assert_eq!(report.rows, TextRows::Names(vec!["target".into()]));
    let usage = text(
        &handle,
        TextSearchRequest {
            query: Some("color".into()),
            path_prefix: Some("src/lib.rs".into()),
            group_by: Some(TextGrouping::Usage),
            max_per_file: Some(20),
            ..Default::default()
        },
    );
    let QueryOutput::TextSearch(report) = usage.value() else {
        panic!()
    };
    assert_eq!(report.excluded_by_usage, 1);
    let structural = text(
        &handle,
        TextSearchRequest {
            query: Some("target()".into()),
            structural: Some(true),
            language: Some("Rust".into()),
            ..Default::default()
        },
    );
    let QueryOutput::TextSearch(report) = structural.value() else {
        panic!()
    };
    assert!(report.structural && report.total_matches > 0);
    let detected = text(
        &handle,
        TextSearchRequest {
            query: Some(r"let\s+color".into()),
            ..Default::default()
        },
    );
    let QueryOutput::TextSearch(report) = detected.value() else {
        panic!()
    };
    assert!(report.auto_detected_regex);
}

#[test]
fn rich_symbol_search_browses_with_language_kind_and_explicit_invalid_options() {
    let root = fixture();
    let runtime = ProcessIndexRuntime::acquire().unwrap();
    let handle = open(&runtime, root.path());
    let found = handle
        .query(
            &QueryRequest::SymbolSearch(SymbolSearchRequest {
                language: Some("Rust".into()),
                kind: Some("function".into()),
                path_prefix: Some("src/lib.rs".into()),
                limit: Some(1),
                ..Default::default()
            }),
            QueryLimits::default(),
        )
        .unwrap();
    let QueryOutput::SymbolSearch(report) = found.value() else {
        panic!()
    };
    assert_eq!(report.symbols.len(), 1);
    assert_eq!(report.overflow_count, 1);
    assert!(found.truncated());
    assert!(
        serde_json::from_str::<TextSearchRequest>(r#"{"query":"color","invented":true}"#).is_err()
    );
    assert!(
        serde_json::from_str::<TextSearchRequest>(r#"{"query":"color","group_by":"invented"}"#)
            .is_err()
    );
    let invalid = handle
        .query(
            &QueryRequest::TextSearch(TextSearchRequest {
                query: Some("color".into()),
                regex: Some(true),
                whole_word: Some(true),
                ..Default::default()
            }),
            QueryLimits::default(),
        )
        .unwrap_err();
    assert_eq!(invalid.kind(), QueryRefusalKind::UnsupportedOption);
}

/// SF-TE-07 embed lane: per-file counts lift every display cap, match an
/// independent `rg -F -s --count` oracle, and report the test-code remainder.
#[test]
fn count_grouping_matches_line_oracle_and_reports_hidden_tests() {
    let root = tempfile::tempdir().unwrap();
    git2::Repository::init(root.path()).unwrap();
    fs::create_dir(root.path().join("src")).unwrap();
    fs::create_dir(root.path().join("tests")).unwrap();
    let mut many = String::from("pub fn many() {\n");
    for i in 0..60 {
        many.push_str(&format!("    let needle_{i} = {i};\n"));
    }
    many.push_str("}\n\n#[cfg(test)]\nmod tests {\n    fn t() { let needle = 0; }\n}\n");
    fs::write(root.path().join("src/many.rs"), many).unwrap();
    fs::write(
        root.path().join("src/few.rs"),
        "pub fn first() {\n    let marker_body_only = 0;\n    let needle_a = 1;\n}\n",
    )
    .unwrap();
    fs::write(
        root.path().join("tests/it_test.rs"),
        "fn a() { let needle = 1; }\nfn b() { let needle = 2; }\n",
    )
    .unwrap();
    let runtime = ProcessIndexRuntime::acquire().unwrap();
    let handle = open(&runtime, root.path());
    let counts = |include_tests| {
        let claim = text(
            &handle,
            TextSearchRequest {
                query: Some("needle".into()),
                case_sensitive: Some(true),
                group_by: Some(TextGrouping::Count),
                include_tests,
                limit: Some(1),
                max_per_file: Some(1),
                ..Default::default()
            },
        );
        let QueryOutput::TextSearch(report) = claim.value() else {
            panic!()
        };
        let TextRows::Counts(rows) = &report.rows else {
            panic!("{:?}", report.rows)
        };
        let rows: std::collections::BTreeMap<String, u64> = rows
            .iter()
            .map(|row| (row.path.clone(), row.count))
            .collect();
        (rows, report.hidden_test_matches)
    };
    let (all, hidden) = counts(Some(true));
    assert_eq!(
        all,
        std::collections::BTreeMap::from([
            ("src/few.rs".to_string(), 1),
            ("src/many.rs".to_string(), 61),
            ("tests/it_test.rs".to_string(), 2),
        ])
    );
    assert_eq!(hidden, None, "tests already included: nothing to report");
    let (visible, hidden) = counts(None);
    assert_eq!(
        visible,
        std::collections::BTreeMap::from([
            ("src/few.rs".to_string(), 1),
            ("src/many.rs".to_string(), 60),
        ])
    );
    assert_eq!(hidden, Some(3));

    // SF-TE-08 embed lane: the symbol group carries its body on request only.
    let grouped = |include_body| {
        let claim = text(
            &handle,
            TextSearchRequest {
                query: Some("needle".into()),
                path_prefix: Some("src/few.rs".into()),
                group_by: Some(TextGrouping::Symbol),
                include_body,
                ..Default::default()
            },
        );
        let QueryOutput::TextSearch(report) = claim.value() else {
            panic!()
        };
        let TextRows::Symbols { groups, .. } = &report.rows else {
            panic!()
        };
        groups[0].body.clone()
    };
    assert!(
        grouped(Some(true))
            .expect("body requested")
            .contains("let marker_body_only = 0;")
    );
    assert_eq!(grouped(None), None);
}