pub mod conventions;
pub(crate) mod edit;
pub(crate) mod edit_format;
pub mod edit_hooks;
pub mod edit_plan;
pub mod explore;
pub mod format;
pub mod investigation;
pub mod prompts;
pub mod resources;
pub(crate) mod search_format;
pub mod session;
pub mod smart_query;
pub mod tools;
use std::path::PathBuf;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
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::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) 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>,
}
impl SymForgeServer {
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();
Self {
index,
tool_router: Self::tool_router(),
prompt_router: Self::prompt_router(),
project_name,
watcher_info,
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()),
}
}
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());
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())),
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()),
}
}
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;
}
pub(crate) fn note_worktree_misuse_if_flag_on(&self, working_directory: Option<&str>) {
if working_directory.is_none() && crate::worktree::feature_flag_enabled() {
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) 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()?;
if self.daemon_degraded.load(Ordering::Relaxed) {
return None;
}
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)) => 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"
);
}
}
}
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)) => 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) {
if self.index.published_state().file_count > 0 {
return;
}
let repo_root = self.capture_repo_root();
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"
);
crate::live_index::git_temporal::spawn_git_temporal_computation(
Arc::clone(&self.index),
root,
);
}
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" => self.health().await,
"conventions" => self.conventions().await,
other => format!("dispatch_tool_for_tests: unknown tool '{other}'"),
}
}
}
#[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(),
)
}
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 }
}
}