pub mod conventions;
pub(crate) mod edit;
pub(crate) mod edit_format;
pub mod edit_hooks;
pub mod edit_plan;
pub(crate) mod edit_tools;
pub mod explore;
pub mod format;
pub mod investigation;
pub mod prompts;
pub(crate) mod read_tools;
pub mod resources;
pub mod result_status;
pub(crate) mod search_format;
pub(crate) mod search_tools;
pub mod session;
pub mod smart_query;
pub mod tools;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::Duration;
use parking_lot::{Mutex, RwLock};
use rmcp::RoleServer;
use rmcp::handler::server::router::prompt::PromptRouter;
use rmcp::handler::server::router::tool::ToolRouter;
use rmcp::model::{
GetPromptRequestParams, GetPromptResult, ListPromptsResult, ListResourceTemplatesResult,
ListResourcesResult, PaginatedRequestParams, ReadResourceRequestParams, ReadResourceResult,
ServerCapabilities, ServerInfo, Tool,
};
use rmcp::service::RequestContext;
use rmcp::{ServerHandler, prompt_handler, tool_handler};
use crate::live_index::SharedIndex;
use crate::protocol::result_status::OutcomeClass;
use crate::sidecar::TokenStats;
use crate::watcher::WatcherInfo;
#[derive(Clone)]
pub struct SymForgeServer {
pub(crate) index: SharedIndex,
pub(crate) tool_router: ToolRouter<Self>,
pub(crate) prompt_router: PromptRouter<Self>,
pub(crate) project_name: String,
pub(crate) watcher_info: Arc<Mutex<WatcherInfo>>,
pub(crate) watcher_handle: Arc<Mutex<Option<crate::watcher::WatcherTaskHandle>>>,
pub(crate) repo_root: Arc<RwLock<Option<PathBuf>>>,
pub(crate) token_stats: Option<Arc<TokenStats>>,
pub(crate) daemon_client: Option<Arc<tokio::sync::RwLock<crate::daemon::DaemonSessionClient>>>,
pub(crate) daemon_degraded: Arc<AtomicBool>,
pub(crate) session_context: Arc<session::SessionContext>,
pub(crate) worktree_misuse: Arc<crate::worktree::WorktreeMisuseCounter>,
pub(crate) analytics_recorder: Arc<RwLock<crate::analytics::AnalyticsRecorder>>,
}
fn default_analytics_db_path(repo_root: Option<&Path>) -> PathBuf {
repo_root
.map(|root| root.join(crate::paths::SYMFORGE_ANALYTICS_DB_PATH))
.unwrap_or_else(|| PathBuf::from(crate::paths::SYMFORGE_ANALYTICS_DB_PATH))
}
fn disabled_analytics_recorder(repo_root: Option<&Path>) -> crate::analytics::AnalyticsRecorder {
crate::analytics::AnalyticsRecorder::disabled(default_analytics_db_path(repo_root))
}
fn estimate_tokens(response_bytes: u64) -> u64 {
response_bytes.saturating_add(3) / 4
}
impl SymForgeServer {
pub(crate) fn tool_router() -> ToolRouter<Self> {
Self::core_tool_router() + Self::edit_tool_router()
}
pub fn new(
index: SharedIndex,
project_name: String,
watcher_info: Arc<Mutex<WatcherInfo>>,
repo_root: Option<PathBuf>,
token_stats: Option<Arc<TokenStats>>,
) -> Self {
crate::worktree::register_if_feature_enabled();
let analytics_recorder = disabled_analytics_recorder(repo_root.as_deref());
Self {
index,
tool_router: Self::tool_router(),
prompt_router: Self::prompt_router(),
project_name,
watcher_info,
watcher_handle: Arc::new(Mutex::new(None)),
repo_root: Arc::new(RwLock::new(repo_root)),
token_stats,
daemon_client: None,
daemon_degraded: Arc::new(AtomicBool::new(false)),
session_context: Arc::new(session::SessionContext::new()),
worktree_misuse: Arc::new(crate::worktree::WorktreeMisuseCounter::new()),
analytics_recorder: Arc::new(RwLock::new(analytics_recorder)),
}
}
pub fn new_daemon_proxy(daemon_client: crate::daemon::DaemonSessionClient) -> Self {
use crate::watcher::WatcherInfo;
crate::worktree::register_if_feature_enabled();
let project_name = daemon_client.project_name().to_string();
let repo_root = daemon_client.project_root().map(|p| p.to_path_buf());
let analytics_recorder = disabled_analytics_recorder(repo_root.as_deref());
Self {
index: crate::live_index::LiveIndex::empty(),
tool_router: Self::tool_router(),
prompt_router: Self::prompt_router(),
project_name,
watcher_info: Arc::new(Mutex::new(WatcherInfo::default())),
watcher_handle: Arc::new(Mutex::new(None)),
repo_root: Arc::new(RwLock::new(repo_root)),
token_stats: None,
daemon_client: Some(Arc::new(tokio::sync::RwLock::new(daemon_client))),
daemon_degraded: Arc::new(AtomicBool::new(false)),
session_context: Arc::new(session::SessionContext::new()),
worktree_misuse: Arc::new(crate::worktree::WorktreeMisuseCounter::new()),
analytics_recorder: Arc::new(RwLock::new(analytics_recorder)),
}
}
pub fn index(&self) -> &SharedIndex {
&self.index
}
pub fn tool_definitions() -> Vec<Tool> {
Self::tool_router().list_all()
}
pub(crate) fn capture_repo_root(&self) -> Option<PathBuf> {
self.repo_root.read().clone()
}
pub(crate) fn bump_frecency(&self, paths: &[PathBuf]) {
if let Some(root) = self.capture_repo_root() {
crate::live_index::frecency::bump(&root, paths);
}
}
pub(crate) fn effective_repo_root_for_git_tools(&self) -> Option<PathBuf> {
self.capture_repo_root()
.or_else(crate::discovery::find_project_root)
}
pub(crate) fn set_repo_root(&self, repo_root: Option<PathBuf>) {
*self.repo_root.write() = repo_root.clone();
if self.analytics_recorder.read().status().disabled {
*self.analytics_recorder.write() = disabled_analytics_recorder(repo_root.as_deref());
}
}
pub(crate) fn note_worktree_misuse_if_active(&self, working_directory: Option<&str>) {
if working_directory.is_none()
&& crate::worktree::routing_policy_from_env()
== crate::capability::WorktreeRoutingPolicy::ExplicitCallTime
{
self.worktree_misuse.record_missing_working_directory();
}
}
pub(crate) fn record_read_savings(&self, saved_tokens: u64) {
if let Some(ref stats) = self.token_stats {
stats
.read_saved_tokens
.fetch_add(saved_tokens, std::sync::atomic::Ordering::Relaxed);
stats
.read_fires
.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
}
}
pub(crate) fn record_tool_savings(&self, estimated_raw_tokens: u64, output_tokens: u64) {
if let Some(ref stats) = self.token_stats {
let saved = estimated_raw_tokens.saturating_sub(output_tokens);
stats
.read_saved_tokens
.fetch_add(saved, std::sync::atomic::Ordering::Relaxed);
stats
.read_fires
.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
}
}
pub(crate) fn record_tool_savings_named(
&self,
tool_name: &str,
estimated_raw_tokens: u64,
output_tokens: u64,
) {
if let Some(ref stats) = self.token_stats {
let saved = estimated_raw_tokens.saturating_sub(output_tokens);
stats
.read_saved_tokens
.fetch_add(saved, std::sync::atomic::Ordering::Relaxed);
stats
.read_fires
.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
stats.record_tool_tokens(tool_name, output_tokens, saved);
}
}
pub(crate) fn record_tool_completion(
&self,
tool_name: &'static str,
response_text: &str,
duration: Duration,
outcome_class: OutcomeClass,
) {
let recorder = self.analytics_recorder.read().clone();
let response_bytes = response_text.len() as u64;
let observation = crate::analytics::AnalyticsObservation::new(
tool_name,
crate::analytics::AnalyticsSurface::Tool,
recorder.configured_scope(),
response_bytes,
Some(estimate_tokens(response_bytes)),
duration,
!outcome_class.is_error(),
outcome_class,
);
let _ = recorder.enqueue(observation);
}
#[cfg(test)]
pub(crate) fn set_analytics_recorder_for_tests(
&self,
recorder: crate::analytics::AnalyticsRecorder,
) {
*self.analytics_recorder.write() = recorder;
}
#[cfg(test)]
pub(crate) fn analytics_queue_status_for_tests(
&self,
) -> crate::analytics::AnalyticsQueueStatus {
self.analytics_recorder.read().status()
}
pub(crate) async fn proxy_tool_call<T>(&self, tool_name: &str, params: &T) -> Option<String>
where
T: serde::Serialize,
{
let daemon_lock = self.daemon_client.as_ref()?;
let was_degraded = self.daemon_degraded.load(Ordering::Relaxed);
let value = match serde_json::to_value(params) {
Ok(value) => value,
Err(error) => return Some(format!("Daemon proxy serialization failed: {error}")),
};
{
let client = daemon_lock.read().await;
match tokio::time::timeout(
std::time::Duration::from_secs(10),
client.call_tool_value(tool_name, value.clone()),
)
.await
{
Ok(Ok(result)) => {
self.daemon_degraded.store(false, Ordering::Relaxed);
return Some(result);
}
Ok(Err(error)) => {
tracing::warn!(
tool = tool_name,
"daemon proxy call failed, attempting reconnect: {error}"
);
}
Err(_elapsed) => {
tracing::warn!(
tool = tool_name,
"daemon proxy call timed out after 10s, attempting reconnect"
);
}
}
}
if was_degraded {
tracing::warn!(
tool = tool_name,
"daemon proxy probe failed while degraded, falling back to local execution"
);
self.ensure_local_index().await;
return None;
}
let reconnected = {
let mut client = daemon_lock.write().await;
match client.reconnect().await {
Ok(new_client) => {
tracing::info!("daemon reconnected successfully");
*client = new_client;
true
}
Err(reconnect_error) => {
tracing::warn!(
"daemon reconnect failed, falling back to local execution: {reconnect_error}"
);
self.daemon_degraded.store(true, Ordering::Relaxed);
self.ensure_local_index().await;
false
}
}
};
if !reconnected {
return None;
}
{
let client = daemon_lock.read().await;
match tokio::time::timeout(
std::time::Duration::from_secs(30),
client.call_tool_value(tool_name, value),
)
.await
{
Ok(Ok(result)) => {
self.daemon_degraded.store(false, Ordering::Relaxed);
Some(result)
}
Ok(Err(error)) => {
tracing::warn!(
tool = tool_name,
"daemon proxy call failed after reconnect, falling back to local: {error}"
);
self.daemon_degraded.store(true, Ordering::Relaxed);
self.ensure_local_index().await;
None
}
Err(_elapsed) => {
tracing::warn!(
tool = tool_name,
"daemon proxy call timed out after reconnect, falling back to local"
);
self.daemon_degraded.store(true, Ordering::Relaxed);
self.ensure_local_index().await;
None
}
}
}
}
pub(crate) async fn proxy_tool_call_without_params(&self, tool_name: &str) -> Option<String> {
self.proxy_tool_call(tool_name, &serde_json::json!({}))
.await
}
async fn ensure_local_index(&self) {
{
let mut watcher = self.watcher_info.lock();
*watcher = WatcherInfo::detached_local_fallback();
}
let repo_root = self.capture_repo_root();
let published = self.index.published_state();
if published.file_count > 0 {
let target_root = repo_root
.as_deref()
.map(crate::live_index::store::normalize_root);
match (&published.indexed_root, &target_root) {
(Some(indexed), Some(target)) if indexed == target => return,
(_, None) => return,
_ => {}
}
}
if let Some(root) = repo_root {
tracing::info!(
root = %root.display(),
"daemon unreachable — loading local index as fallback"
);
match self.index.reload(&root) {
Ok(()) => {
let published = self.index.published_state();
tracing::info!(
files = published.file_count,
symbols = published.symbol_count,
"local fallback index loaded"
);
let expected_gen = self.index.current_project_generation();
crate::live_index::git_temporal::spawn_git_temporal_computation(
Arc::clone(&self.index),
root,
expected_gen,
);
}
Err(error) => {
tracing::error!("failed to load local fallback index: {error}");
}
}
} else {
tracing::warn!("daemon unreachable and no repo root available for local fallback");
}
}
#[doc(hidden)]
pub async fn dispatch_tool_for_tests(
&self,
tool_name: &str,
params: serde_json::Value,
) -> String {
use rmcp::handler::server::wrapper::Parameters;
fn decode<T: serde::de::DeserializeOwned>(params: serde_json::Value) -> Result<T, String> {
serde_json::from_value(params).map_err(|e| format!("invalid tool parameters: {e}"))
}
macro_rules! call {
($method:ident, $input:ty) => {{
match decode::<$input>(params) {
Ok(input) => self.$method(Parameters(input)).await,
Err(e) => e,
}
}};
}
match tool_name {
"replace_symbol_body" => call!(replace_symbol_body, edit::ReplaceSymbolBodyInput),
"insert_symbol" => call!(insert_symbol, edit::InsertSymbolInput),
"delete_symbol" => call!(delete_symbol, edit::DeleteSymbolInput),
"edit_within_symbol" => call!(edit_within_symbol, edit::EditWithinSymbolInput),
"batch_edit" => call!(batch_edit, edit::BatchEditInput),
"batch_rename" => call!(batch_rename, edit::BatchRenameInput),
"batch_insert" => call!(batch_insert, edit::BatchInsertInput),
"search_files" => call!(search_files, tools::SearchFilesInput),
"search_text" => call!(search_text, tools::SearchTextInput),
"search_symbols" => call!(search_symbols, tools::SearchSymbolsInput),
"get_file_context" => call!(get_file_context, tools::GetFileContextInput),
"get_file_content" => call!(get_file_content, tools::GetFileContentInput),
"get_symbol" => call!(get_symbol, tools::GetSymbolInput),
"get_symbol_context" => call!(get_symbol_context, tools::GetSymbolContextInput),
"health" => call!(health, tools::HealthInput),
"health_compact" => self.health_compact().await,
"conventions" => self.conventions().await,
other => format!("dispatch_tool_for_tests: unknown tool '{other}'"),
}
}
#[doc(hidden)]
pub async fn dispatch_tool_result_for_tests(
&self,
tool_name: &str,
params: serde_json::Value,
) -> Result<rmcp::model::CallToolResult, rmcp::ErrorData> {
use rmcp::handler::server::wrapper::Parameters;
fn invalid_request_result(
tool_name: &str,
message: impl Into<String>,
) -> Result<rmcp::model::CallToolResult, rmcp::ErrorData> {
let text = format!(
"Invalid request for tool `{tool_name}`: {}\nRecovery: compare the request JSON with the advertised input schema from tool_definitions().",
message.into()
);
Ok(
result_status::ResultStatus::new(result_status::OutcomeClass::InvalidRequest)
.into_call_tool_result(text),
)
}
fn decode<T: serde::de::DeserializeOwned>(params: serde_json::Value) -> Result<T, String> {
serde_json::from_value(params).map_err(|e| format!("invalid tool parameters: {e}"))
}
macro_rules! call_statused {
($method:ident, $input:ty) => {{
match decode::<$input>(params) {
Ok(input) => self.$method(Parameters(input)).await,
Err(error) => invalid_request_result(tool_name, error),
}
}};
}
match tool_name {
"replace_symbol_body" => {
call_statused!(replace_symbol_body_tool, edit::ReplaceSymbolBodyInput)
}
"batch_edit" => call_statused!(batch_edit_tool, edit::BatchEditInput),
"batch_insert" => call_statused!(batch_insert_tool, edit::BatchInsertInput),
"search_files" => call_statused!(search_files_tool, tools::SearchFilesInput),
"search_text" => call_statused!(search_text_tool, tools::SearchTextInput),
"search_symbols" => call_statused!(search_symbols_tool, tools::SearchSymbolsInput),
"get_file_content" => {
call_statused!(get_file_content_tool, tools::GetFileContentInput)
}
"get_symbol" => call_statused!(get_symbol_tool, tools::GetSymbolInput),
"get_symbol_context" => {
call_statused!(get_symbol_context_tool, tools::GetSymbolContextInput)
}
"find_references" => call_statused!(find_references_tool, tools::FindReferencesInput),
other => {
let text = format!(
"Unsupported tool `{other}` in public conformance harness.\nRecovery: add a statused dispatcher branch before adding the case, or remove the case from the public corpus."
);
Ok(
result_status::ResultStatus::new(result_status::OutcomeClass::InvalidRequest)
.into_call_tool_result(text),
)
}
}
}
}
#[tool_handler(router = self.tool_router)]
#[prompt_handler(router = self.prompt_router)]
impl ServerHandler for SymForgeServer {
fn get_info(&self) -> ServerInfo {
ServerInfo::new(
ServerCapabilities::builder()
.enable_tools()
.enable_prompts()
.enable_resources()
.build(),
)
.with_server_info(rmcp::model::Implementation::new(
"symforge",
env!("CARGO_PKG_VERSION"),
))
}
fn list_resources(
&self,
_request: Option<PaginatedRequestParams>,
_context: RequestContext<RoleServer>,
) -> impl std::future::Future<Output = Result<ListResourcesResult, rmcp::ErrorData>> + Send + '_
{
std::future::ready(Ok(ListResourcesResult {
resources: self.resource_definitions(),
..Default::default()
}))
}
fn list_resource_templates(
&self,
_request: Option<PaginatedRequestParams>,
_context: RequestContext<RoleServer>,
) -> impl std::future::Future<Output = Result<ListResourceTemplatesResult, rmcp::ErrorData>>
+ Send
+ '_ {
std::future::ready(Ok(ListResourceTemplatesResult {
resource_templates: self.resource_template_definitions(),
..Default::default()
}))
}
fn read_resource(
&self,
request: ReadResourceRequestParams,
_context: RequestContext<RoleServer>,
) -> impl std::future::Future<Output = Result<ReadResourceResult, rmcp::ErrorData>> + Send + '_
{
let uri = request.uri;
async move { self.read_resource_uri(&uri).await }
}
}
#[cfg(test)]
mod tests {
use super::*;
use axum::Router;
use axum::extract::State;
use axum::routing::post;
use std::sync::atomic::{AtomicUsize, Ordering};
use tokio::net::TcpListener;
#[derive(Clone)]
struct FakeToolState {
calls: Arc<AtomicUsize>,
body: Arc<String>,
}
async fn fake_tool_handler(State(state): State<FakeToolState>) -> String {
state.calls.fetch_add(1, Ordering::Relaxed);
state.body.as_ref().clone()
}
async fn spawn_fake_tool_server(
body: &str,
) -> (String, tokio::sync::oneshot::Sender<()>, Arc<AtomicUsize>) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind fake daemon tool server");
let base_url = format!("http://{}", listener.local_addr().expect("listener addr"));
let calls = Arc::new(AtomicUsize::new(0));
let state = FakeToolState {
calls: Arc::clone(&calls),
body: Arc::new(body.to_string()),
};
let app = Router::new()
.route(
"/v1/sessions/{session_id}/tools/{tool_name}",
post(fake_tool_handler),
)
.with_state(state);
let (shutdown_tx, shutdown_rx) = tokio::sync::oneshot::channel();
tokio::spawn(async move {
let shutdown = async move {
let _ = shutdown_rx.await;
};
let _ = axum::serve(listener, app)
.with_graceful_shutdown(shutdown)
.await;
});
(base_url, shutdown_tx, calls)
}
#[tokio::test]
async fn daemon_degraded_clears_on_next_success() {
let (base_url, shutdown, calls) = spawn_fake_tool_server("daemon-ok").await;
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"project-id".to_string(),
"session-id".to_string(),
"project-name".to_string(),
);
let server = SymForgeServer::new_daemon_proxy(daemon_client);
server.daemon_degraded.store(true, Ordering::Relaxed);
let result = server
.proxy_tool_call("health", &serde_json::json!({}))
.await;
let _ = shutdown.send(());
assert_eq!(result.as_deref(), Some("daemon-ok"));
assert_eq!(
calls.load(Ordering::Relaxed),
1,
"degraded proxy should still probe the daemon once"
);
assert!(
!server.daemon_degraded.load(Ordering::Relaxed),
"successful proxy call should clear daemon_degraded"
);
}
fn make_local_server(repo_root: Option<std::path::PathBuf>) -> SymForgeServer {
let index = crate::live_index::LiveIndex::empty();
let watcher_info = Arc::new(Mutex::new(WatcherInfo::default()));
SymForgeServer::new(
index,
"test_project".to_string(),
watcher_info,
repo_root,
None,
)
}
fn seed_project(dir: &std::path::Path, file_name: &str, body: &str) {
std::fs::write(dir.join(file_name), body).expect("seed project source file");
}
#[tokio::test]
async fn ensure_local_index_reloads_on_root_mismatch_without_reset() {
let dir_a = tempfile::TempDir::new().expect("temp dir A");
let dir_b = tempfile::TempDir::new().expect("temp dir B");
seed_project(dir_a.path(), "alpha.rs", "fn alpha_only() {}\n");
seed_project(dir_b.path(), "beta.rs", "fn beta_only() {}\n");
let server = make_local_server(Some(dir_a.path().to_path_buf()));
server.ensure_local_index().await;
let published_a = server.index.published_state();
assert!(
published_a.file_count > 0,
"project A should have loaded a non-empty index"
);
assert_eq!(
published_a.indexed_root.as_deref(),
Some(crate::live_index::store::normalize_root(dir_a.path()).as_path()),
"loaded index must record project A's normalized root"
);
assert!(
server.index.read().get_file("alpha.rs").is_some(),
"project A's file should be present after the first load"
);
server.set_repo_root(Some(dir_b.path().to_path_buf()));
server.ensure_local_index().await;
let published_b = server.index.published_state();
assert_eq!(
published_b.indexed_root.as_deref(),
Some(crate::live_index::store::normalize_root(dir_b.path()).as_path()),
"after a root switch, ensure_local_index must serve project B's root"
);
assert!(
server.index.read().get_file("beta.rs").is_some(),
"project B's file must be present after the root-mismatch reload"
);
assert!(
server.index.read().get_file("alpha.rs").is_none(),
"project A's stale file must be gone after switching to project B"
);
}
#[tokio::test]
async fn ensure_local_index_does_not_reload_on_repeated_same_root_calls() {
let dir_a = tempfile::TempDir::new().expect("temp dir A");
seed_project(dir_a.path(), "alpha.rs", "fn alpha_only() {}\n");
let server = make_local_server(Some(dir_a.path().to_path_buf()));
server.ensure_local_index().await;
let gen_after_first = server.index.current_project_generation();
let root_after_first = server.index.published_state().indexed_root.clone();
assert!(
server.index.published_state().file_count > 0,
"first ensure_local_index call should have loaded project A"
);
for _ in 0..3 {
server.ensure_local_index().await;
}
assert_eq!(
server.index.current_project_generation(),
gen_after_first,
"repeated same-root ensure_local_index calls must not reload (project generation must not change)"
);
assert_eq!(
server.index.published_state().indexed_root,
root_after_first,
"repeated same-root calls must leave the recorded root unchanged"
);
}
#[test]
fn get_info_reports_symforge_name_and_crate_version() {
let server = make_local_server(None);
let info = ServerHandler::get_info(&server);
assert_eq!(
info.server_info.name, "symforge",
"serverInfo.name must identify symforge, not the rmcp framework"
);
assert_eq!(
info.server_info.version,
env!("CARGO_PKG_VERSION"),
"serverInfo.version must track the symforge crate version"
);
}
}