use super::HankMcpServer;
use crate::mcp::tools::{
AnalyzeRequest, CommunitiesRequest, DataflowRequest, ImpactRequest, NeighborsRequest,
ReferencesRequest, SymbolsRequest, VerifyRequest,
};
use rmcp::handler::server::wrapper::Parameters;
use rmcp::model::CallToolResult;
const KNOWN_TIERS: &[&str] = &["treesitter", "lsp", "cpg"];
fn fixture() -> tempfile::TempDir {
let dir = tempfile::tempdir().unwrap();
std::fs::write(dir.path().join("x.rs"), "fn a() { b(); }\nfn b() {}\n").unwrap();
dir
}
fn server(dir: &tempfile::TempDir) -> HankMcpServer {
HankMcpServer::new(dir.path().to_path_buf(), None, None)
}
fn served(result: Result<CallToolResult, rmcp::ErrorData>) -> serde_json::Value {
let result = result.expect("handler returned Ok");
let wire = serde_json::to_value(&result).expect("CallToolResult serializes");
let text = wire
.pointer("/content/0/text")
.and_then(serde_json::Value::as_str)
.unwrap_or_else(|| panic!("no text content in result: {wire}"));
serde_json::from_str(text).expect("served payload is JSON")
}
fn carries_tier(v: &serde_json::Value) -> bool {
match v {
serde_json::Value::Object(m) => m.contains_key("tier") || m.values().any(carries_tier),
serde_json::Value::Array(a) => a.iter().any(carries_tier),
_ => false,
}
}
fn assert_top_level_tier(payload: &serde_json::Value, tool: &str) {
let tier = payload
.get("tier")
.and_then(serde_json::Value::as_str)
.unwrap_or_else(|| panic!("{tool}: no top-level `tier` in {payload}"));
assert!(
KNOWN_TIERS.contains(&tier),
"{tool}: tier {tier:?} is not one of {KNOWN_TIERS:?}"
);
}
#[tokio::test]
async fn impact_carries_a_top_level_tier() {
let dir = fixture();
let payload = served(
server(&dir)
.hank_impact(Parameters(ImpactRequest {
symbol: "b".into(),
path: None,
hops: None,
cochange: None,
}))
.await,
);
assert_top_level_tier(&payload, "hank_impact");
let first = &payload["reachable"][0];
assert_eq!(
first["tier"], "treesitter",
"reach item missing tier: {first}"
);
}
#[tokio::test]
async fn impact_on_a_missing_symbol_still_declares_its_tier() {
let dir = fixture();
let payload = served(
server(&dir)
.hank_impact(Parameters(ImpactRequest {
symbol: "does_not_exist".into(),
path: None,
hops: None,
cochange: None,
}))
.await,
);
assert_eq!(payload["found"], false);
assert_top_level_tier(&payload, "hank_impact(not-found)");
}
#[tokio::test]
async fn callers_and_callees_carry_a_top_level_tier() {
let dir = fixture();
let callers = served(
server(&dir)
.hank_callers(Parameters(NeighborsRequest {
symbol: "b".into(),
path: None,
}))
.await,
);
assert_top_level_tier(&callers, "hank_callers");
let callees = served(
server(&dir)
.hank_callees(Parameters(NeighborsRequest {
symbol: "a".into(),
path: None,
}))
.await,
);
assert_top_level_tier(&callees, "hank_callees");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn an_unscoped_query_uses_the_daemon_and_a_path_scoped_one_never_does() {
let dir = fixture(); let engine = crate::daemon::ResidentEngine::build(dir.path(), None).unwrap();
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
tokio::spawn(async move {
let _ = axum::serve(listener, crate::daemon::http::router(engine)).await;
});
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
let config = dir.path().join("daemon-config.toml");
std::fs::write(
&config,
format!(
"[hank.serve]\nuse_daemon = true\nbind_address = \"127.0.0.1\"\n\
mcp_http_port = {port}\n"
),
)
.unwrap();
let server = HankMcpServer::new(dir.path().to_path_buf(), None, Some(config));
std::fs::write(dir.path().join("late.rs"), "fn late() { b(); }\n").unwrap();
let resident = served(
server
.hank_callers(Parameters(NeighborsRequest {
symbol: "b".into(),
path: None,
}))
.await,
);
let names: Vec<&str> = resident["neighbors"]
.as_array()
.unwrap()
.iter()
.map(|n| n["name"].as_str().unwrap())
.collect();
assert!(names.contains(&"a"), "got {names:?}");
assert!(
!names.contains(&"late"),
"`late` postdates the resident graph; its presence means the transient \
path answered an unscoped query despite a usable daemon: {names:?}"
);
assert_top_level_tier(&resident, "hank_callers(resident)");
let scoped = served(
server
.hank_callers(Parameters(NeighborsRequest {
symbol: "b".into(),
path: Some(".".into()),
}))
.await,
);
let names: Vec<&str> = scoped["neighbors"]
.as_array()
.unwrap()
.iter()
.map(|n| n["name"].as_str().unwrap())
.collect();
assert!(
names.contains(&"late"),
"a path-scoped query must be answered transiently, not by the daemon: {names:?}"
);
}
#[tokio::test]
async fn dataflow_carries_a_top_level_tier() {
let dir = fixture();
let payload = served(
server(&dir)
.hank_dataflow(Parameters(DataflowRequest {
function: "a".into(),
path: None,
var: None,
forward: None,
hops: None,
}))
.await,
);
assert_top_level_tier(&payload, "hank_dataflow");
}
#[tokio::test]
async fn every_fact_serving_response_carries_a_tier() {
let dir = fixture();
let s = server(&dir);
let cases: Vec<(&str, serde_json::Value)> = vec![
(
"hank_symbols",
served(
s.hank_symbols(Parameters(SymbolsRequest {
file: "x.rs".into(),
}))
.await,
),
),
(
"hank_references",
served(
s.hank_references(Parameters(ReferencesRequest {
symbol: Some("a".into()),
path: None,
at_file: None,
at_line: None,
}))
.await,
),
),
(
"hank_analyze",
served(
s.hank_analyze(Parameters(AnalyzeRequest { path: None }))
.await,
),
),
(
"hank_communities",
served(
s.hank_communities(Parameters(CommunitiesRequest { path: None }))
.await,
),
),
(
"hank_verify",
served(
s.hank_verify(Parameters(VerifyRequest {
file: "x.rs".into(),
buffer: "fn a() { b(); }\nfn b() {}\n".into(),
}))
.await,
),
),
(
"hank_callers",
served(
s.hank_callers(Parameters(NeighborsRequest {
symbol: "b".into(),
path: None,
}))
.await,
),
),
(
"hank_impact",
served(
s.hank_impact(Parameters(ImpactRequest {
symbol: "b".into(),
path: None,
hops: None,
cochange: None,
}))
.await,
),
),
(
"hank_dataflow",
served(
s.hank_dataflow(Parameters(DataflowRequest {
function: "a".into(),
path: None,
var: None,
forward: None,
hops: None,
}))
.await,
),
),
];
for (tool, payload) in &cases {
assert!(
carries_tier(payload),
"{tool}: served response carries NO tier anywhere: {payload}"
);
}
}
#[tokio::test]
async fn status_advertises_only_implemented_tiers() {
let dir = fixture();
let payload = served(server(&dir).hank_status().await);
assert_eq!(
payload["tiers"],
serde_json::json!(["treesitter"]),
"status advertised a tier with no implementation: {payload}"
);
}
#[tokio::test]
async fn references_declares_its_tier_at_the_top_level() {
let dir = fixture();
let payload = served(
server(&dir)
.hank_references(Parameters(ReferencesRequest {
symbol: Some("definitely_not_here".into()),
path: None,
at_file: None,
at_line: None,
}))
.await,
);
assert_eq!(payload["count"], 0, "fixture has no such symbol: {payload}");
assert_top_level_tier(&payload, "hank_references");
}
#[tokio::test]
#[cfg(feature = "langs-extra")] async fn references_resolves_a_non_rust_definition_on_the_transient_path() {
let dir = tempfile::tempdir().unwrap();
std::fs::write(
dir.path().join("quipu.py"),
"def derive_agents(cfg):\n return cfg\n",
)
.unwrap();
let s = HankMcpServer::new(dir.path().to_path_buf(), None, None);
let payload = served(
s.hank_references(Parameters(ReferencesRequest {
symbol: Some("derive_agents".into()),
at_file: None,
at_line: None,
path: Some(".".into()),
}))
.await,
);
assert_eq!(payload["count"], 1, "python definition missed: {payload}");
assert_eq!(payload["definitions"][0]["file"], "quipu.py");
assert_eq!(payload["definitions"][0]["start_line"], 1);
assert_eq!(payload["searched_symbols"], 1, "{payload}");
}
#[tokio::test]
async fn references_by_position_answers_with_the_one_symbol_pointed_at() {
let dir = tempfile::tempdir().unwrap();
std::fs::write(
dir.path().join("x.rs"),
"struct Alpha;\nimpl Alpha {\n fn build() {}\n}\nstruct Beta;\nimpl Beta {\n fn build() {}\n}\n",
)
.unwrap();
let s = HankMcpServer::new(dir.path().to_path_buf(), None, None);
let by_name = served(
s.hank_references(Parameters(ReferencesRequest {
symbol: Some("build".into()),
path: Some(".".into()),
at_file: None,
at_line: None,
}))
.await,
);
assert_eq!(by_name["count"], 2, "name is ambiguous here: {by_name}");
let by_pos = served(
s.hank_references(Parameters(ReferencesRequest {
symbol: None,
path: Some(".".into()),
at_file: Some("x.rs".into()),
at_line: Some(7),
}))
.await,
);
assert_eq!(by_pos["count"], 1, "position must disambiguate: {by_pos}");
assert_eq!(by_pos["definitions"][0]["start_line"], 7, "{by_pos}");
assert_top_level_tier(&by_pos, "hank_references");
}
#[tokio::test]
async fn references_refuses_half_a_position_rather_than_downgrading_to_a_name() {
let dir = fixture();
let err = server(&dir)
.hank_references(Parameters(ReferencesRequest {
symbol: Some("a".into()),
path: Some(".".into()),
at_file: Some("x.rs".into()),
at_line: None,
}))
.await;
assert!(err.is_err(), "half a position must be refused, not guessed");
}