symforge 11.10.3

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

#[test]
fn usage_counts_decoded_strings_and_raw_bytes_without_json_escape_expansion() {
    use symforge::embed::parity::read::{FileContentRequest, SourcePageRequest};
    let root = tempfile::tempdir().unwrap();
    let source = "// é \\\\ \"quoted\"\r\npub fn item() {}\r\n";
    fs::write(root.path().join("unicode.rs"), source).unwrap();
    let runtime = ProcessIndexRuntime::acquire().unwrap();
    let handle = open(&runtime, root.path());
    let read = handle
        .query(
            &QueryRequest::FileContent(FileContentRequest {
                path: "unicode.rs".into(),
                ..Default::default()
            }),
            QueryLimits {
                max_results: 1,
                max_bytes: 512,
            },
        )
        .unwrap();
    let QueryOutput::FileContent(content) = read.value() else {
        panic!("content");
    };
    let expected = content.path.len()
        + content.content_hash.len()
        + content.rendered.len()
        + "PublishedGeneration".len();
    assert_eq!(read.usage().decoded_bytes, expected as u64);
    assert_eq!(read.usage().rows, 1);
    assert!(serde_json::to_vec(read.value()).unwrap().len() > expected);
    let page = handle
        .query(
            &QueryRequest::SourcePage(SourcePageRequest {
                path: "unicode.rs".into(),
                offset: 0,
                expected_publication: None,
            }),
            QueryLimits {
                max_results: 1,
                max_bytes: 512,
            },
        )
        .unwrap();
    let QueryOutput::SourcePage(content) = page.value() else {
        panic!("page");
    };
    assert_eq!(
        page.usage().decoded_bytes,
        (content.path.len() + content.content_hash.len() + content.bytes.len()) as u64
    );
    assert_eq!(content.bytes, source.as_bytes());
}
use std::{
    fs,
    time::{Duration, Instant},
};
use symforge::embed::parity::federation::{
    AdmittedQuerySource, FederatedSourceOutcome, FederationRefusalKind, SourceSelection,
    query_sources,
};
use symforge::embed::parity::search::SymbolSearchRequest;
use symforge::embed::parity::{QueryLimits, QueryOutput, QueryPolicy, QueryRequest};
use symforge::embed::{
    EmbeddedSourceHandle, EmbeddedSourceSpec, ProcessIndexRuntime, SourceRuntimePhase,
};
fn open(runtime: &ProcessIndexRuntime, path: &std::path::Path) -> EmbeddedSourceHandle {
    let handle = runtime
        .open_embedded_source(EmbeddedSourceSpec::current_worktree(path.to_path_buf()))
        .unwrap();
    let until = Instant::now() + Duration::from_secs(20);
    while handle.runtime_view().phase != SourceRuntimePhase::Current {
        assert!(Instant::now() < until);
        std::thread::sleep(Duration::from_millis(5));
    }
    handle
}
#[test]
fn admitted_federation_keeps_source_claims_and_refuses_unknown_alias_before_execution() {
    let a = tempfile::tempdir().unwrap();
    let b = tempfile::tempdir().unwrap();
    fs::write(a.path().join("lib.rs"), "pub fn widget_alpha() {}\n").unwrap();
    fs::write(b.path().join("lib.rs"), "pub fn widget_beta() {}\n").unwrap();
    let runtime = ProcessIndexRuntime::acquire().unwrap();
    let a = open(&runtime, a.path());
    let b = open(&runtime, b.path());
    let a_session = a.new_query_session().unwrap();
    let b_session = b.new_query_session().unwrap();
    let sources = [
        AdmittedQuerySource {
            label: "beta",
            handle: &b,
            session: Some(&b_session),
            policy: QueryPolicy::default(),
        },
        AdmittedQuerySource {
            label: "alpha",
            handle: &a,
            session: Some(&a_session),
            policy: QueryPolicy::default(),
        },
    ];
    let query = QueryRequest::SymbolSearch(SymbolSearchRequest {
        query: Some("widget".into()),
        ..Default::default()
    });
    let refusal = query_sources(
        &sources,
        &SourceSelection::Many(vec!["alpha".into(), "foreign".into()]),
        &query,
        QueryLimits::default(),
        None,
    )
    .unwrap_err();
    assert_eq!(refusal.kind, FederationRefusalKind::UnknownSource);
    let inventory = a
        .query_with_session(
            &QueryRequest::ContextInventory,
            QueryLimits::default(),
            &a_session,
            None,
        )
        .unwrap();
    let QueryOutput::ContextInventory(inventory) = inventory.value() else {
        panic!("inventory");
    };
    assert!(inventory.listed_symbols.is_empty());
    let result = query_sources(
        &sources,
        &SourceSelection::All,
        &query,
        QueryLimits::default(),
        None,
    )
    .unwrap();
    assert_eq!(
        result
            .results
            .iter()
            .map(|r| r.source.label.as_str())
            .collect::<Vec<_>>(),
        vec!["alpha", "beta"]
    );
    assert_eq!(result.resolved_sources.len(), 2);
    let mut publications = Vec::new();
    for row in &result.results {
        let FederatedSourceOutcome::Claim(claim) = &row.outcome else {
            panic!("source claim");
        };
        let QueryOutput::SymbolSearch(found) = claim.value() else {
            panic!("symbols");
        };
        assert_eq!(found.symbols.len(), 1);
        assert!(found.symbols[0].symbol.name.ends_with(&row.source.label));
        publications.push(claim.publication_identity());
    }
    assert_ne!(publications[0], publications[1]);
    assert!(result.usage.rows <= 100);
    assert!(result.usage.decoded_bytes <= 65_536);
}
#[test]
fn federation_aggregate_cap_and_duplicate_alias_are_deterministic() {
    let root = tempfile::tempdir().unwrap();
    fs::write(root.path().join("lib.rs"), "pub fn widget() {}\n").unwrap();
    let runtime = ProcessIndexRuntime::acquire().unwrap();
    let handle = open(&runtime, root.path());
    let sources = [AdmittedQuerySource {
        label: "one",
        handle: &handle,
        session: None,
        policy: QueryPolicy::default(),
    }];
    let query = QueryRequest::SymbolSearch(SymbolSearchRequest {
        query: Some("widget".into()),
        ..Default::default()
    });
    let result = query_sources(
        &sources,
        &SourceSelection::Many(vec!["one".into(), "one".into()]),
        &query,
        QueryLimits {
            max_results: 2,
            max_bytes: 2000,
        },
        None,
    )
    .unwrap();
    assert_eq!(result.results.len(), 1);
    assert_eq!(result.resolved_sources.len(), 1);
    assert!(result.usage.rows <= 2);
    assert!(result.usage.decoded_bytes <= 2000);
}