lean_ctx/tools/
mod.rs

1use std::path::Path;
2use std::sync::atomic::{AtomicUsize, Ordering};
3use std::sync::Arc;
4use std::time::Instant;
5use tokio::sync::RwLock;
6
7use crate::core::cache::SessionCache;
8use crate::core::session::SessionState;
9
10pub mod autonomy;
11pub mod ctx_agent;
12pub mod ctx_analyze;
13pub mod ctx_architecture;
14pub mod ctx_artifacts;
15pub mod ctx_benchmark;
16pub mod ctx_callees;
17pub mod ctx_callers;
18pub mod ctx_callgraph;
19pub mod ctx_compile;
20pub mod ctx_compress;
21pub mod ctx_compress_memory;
22pub mod ctx_context;
23pub mod ctx_control;
24pub mod ctx_cost;
25pub mod ctx_dedup;
26pub mod ctx_delta;
27pub mod ctx_discover;
28pub mod ctx_edit;
29pub mod ctx_execute;
30pub mod ctx_expand;
31pub mod ctx_feedback;
32pub mod ctx_fill;
33pub mod ctx_gain;
34pub mod ctx_graph;
35pub mod ctx_graph_diagram;
36pub mod ctx_handoff;
37pub mod ctx_heatmap;
38pub mod ctx_impact;
39pub mod ctx_index;
40pub mod ctx_intent;
41pub mod ctx_knowledge;
42pub mod ctx_knowledge_relations;
43pub mod ctx_metrics;
44pub mod ctx_multi_read;
45pub mod ctx_outline;
46pub mod ctx_overview;
47pub mod ctx_pack;
48pub mod ctx_plan;
49pub mod ctx_prefetch;
50pub mod ctx_preload;
51pub mod ctx_proof;
52pub mod ctx_provider;
53pub mod ctx_read;
54pub mod ctx_response;
55pub mod ctx_review;
56pub mod ctx_routes;
57pub mod ctx_search;
58pub mod ctx_semantic_search;
59pub mod ctx_session;
60pub mod ctx_share;
61pub mod ctx_shell;
62pub mod ctx_smart_read;
63pub mod ctx_symbol;
64pub mod ctx_task;
65pub mod ctx_tree;
66pub mod ctx_verify;
67pub mod ctx_workflow;
68pub mod ctx_wrapped;
69pub mod registered;
70
71const DEFAULT_CACHE_TTL_SECS: u64 = 300;
72
73struct CepComputedStats {
74    cep_score: u32,
75    cache_util: u32,
76    mode_diversity: u32,
77    compression_rate: u32,
78    total_original: u64,
79    total_compressed: u64,
80    total_saved: u64,
81    mode_counts: std::collections::HashMap<String, u64>,
82    complexity: String,
83    cache_hits: u64,
84    total_reads: u64,
85    tool_call_count: u64,
86}
87
88/// Context Reduction Protocol mode controlling output verbosity.
89#[derive(Clone, Copy, Debug, PartialEq, Eq)]
90pub enum CrpMode {
91    Off,
92    Compact,
93    Tdd,
94}
95
96impl CrpMode {
97    /// Reads the CRP mode from the `LEAN_CTX_CRP_MODE` environment variable.
98    pub fn from_env() -> Self {
99        match std::env::var("LEAN_CTX_CRP_MODE")
100            .unwrap_or_default()
101            .to_lowercase()
102            .as_str()
103        {
104            "off" => Self::Off,
105            "compact" => Self::Compact,
106            _ => Self::Tdd,
107        }
108    }
109
110    pub fn parse(s: &str) -> Option<Self> {
111        match s.trim().to_lowercase().as_str() {
112            "off" => Some(Self::Off),
113            "compact" => Some(Self::Compact),
114            "tdd" => Some(Self::Tdd),
115            _ => None,
116        }
117    }
118
119    /// Effective CRP mode: explicit env var wins; otherwise use active profile.
120    pub fn effective() -> Self {
121        if let Ok(v) = std::env::var("LEAN_CTX_CRP_MODE") {
122            if !v.trim().is_empty() {
123                return Self::parse(&v).unwrap_or(Self::Tdd);
124            }
125        }
126        let p = crate::core::profiles::active_profile();
127        Self::parse(p.compression.crp_mode_effective()).unwrap_or(Self::Tdd)
128    }
129
130    /// Returns true if the mode is TDD (maximum compression).
131    pub fn is_tdd(&self) -> bool {
132        *self == Self::Tdd
133    }
134}
135
136/// Thread-safe handle to the shared file content cache.
137pub type SharedCache = Arc<RwLock<SessionCache>>;
138
139#[derive(Clone, Copy, Debug, PartialEq, Eq)]
140pub enum SessionMode {
141    /// Traditional single-client session persistence under `~/.lean-ctx/sessions/`.
142    Personal,
143    /// Context OS mode: shared sessions + event bus for multi-client HTTP/team-server.
144    Shared,
145}
146
147/// Central MCP server state: cache, session, metrics, and autonomy runtime.
148#[derive(Clone)]
149pub struct LeanCtxServer {
150    pub cache: SharedCache,
151    pub session: Arc<RwLock<SessionState>>,
152    pub tool_calls: Arc<RwLock<Vec<ToolCallRecord>>>,
153    pub call_count: Arc<AtomicUsize>,
154    pub cache_ttl_secs: u64,
155    pub last_call: Arc<RwLock<Instant>>,
156    pub agent_id: Arc<RwLock<Option<String>>>,
157    pub client_name: Arc<RwLock<String>>,
158    pub autonomy: Arc<autonomy::AutonomyState>,
159    pub loop_detector: Arc<RwLock<crate::core::loop_detection::LoopDetector>>,
160    pub workflow: Arc<RwLock<Option<crate::core::workflow::WorkflowRun>>>,
161    pub ledger: Arc<RwLock<crate::core::context_ledger::ContextLedger>>,
162    pub pipeline_stats: Arc<RwLock<crate::core::pipeline::PipelineStats>>,
163    pub session_mode: SessionMode,
164    pub workspace_id: String,
165    pub channel_id: String,
166    pub context_os: Option<Arc<crate::core::context_os::ContextOsRuntime>>,
167    pub context_ir: Option<Arc<RwLock<crate::core::context_ir::ContextIrV1>>>,
168    pub registry: Option<Arc<crate::server::registry::ToolRegistry>>,
169    startup_project_root: Option<String>,
170    startup_shell_cwd: Option<String>,
171}
172
173/// Recorded metrics for a single MCP tool invocation.
174#[derive(Clone, Debug)]
175pub struct ToolCallRecord {
176    pub tool: String,
177    pub original_tokens: usize,
178    pub saved_tokens: usize,
179    pub mode: Option<String>,
180    pub duration_ms: u64,
181    pub timestamp: String,
182}
183
184impl Default for LeanCtxServer {
185    fn default() -> Self {
186        Self::new()
187    }
188}
189
190impl LeanCtxServer {
191    /// Creates a new server with default settings, auto-detecting the project root.
192    pub fn new() -> Self {
193        Self::new_with_project_root(None)
194    }
195
196    /// Creates a new server rooted at the given project directory.
197    pub fn new_with_project_root(project_root: Option<&str>) -> Self {
198        Self::new_with_startup(
199            project_root,
200            std::env::current_dir().ok().as_deref(),
201            SessionMode::Personal,
202            "default",
203            "default",
204        )
205    }
206
207    /// Creates a new server in Context OS shared mode for a specific workspace/channel.
208    pub fn new_shared_with_context(
209        project_root: &str,
210        workspace_id: &str,
211        channel_id: &str,
212    ) -> Self {
213        Self::new_with_startup(
214            Some(project_root),
215            std::env::current_dir().ok().as_deref(),
216            SessionMode::Shared,
217            workspace_id,
218            channel_id,
219        )
220    }
221
222    fn new_with_startup(
223        project_root: Option<&str>,
224        startup_cwd: Option<&Path>,
225        session_mode: SessionMode,
226        workspace_id: &str,
227        channel_id: &str,
228    ) -> Self {
229        let ttl = std::env::var("LEAN_CTX_CACHE_TTL")
230            .ok()
231            .and_then(|v| v.parse().ok())
232            .unwrap_or(DEFAULT_CACHE_TTL_SECS);
233
234        let startup = detect_startup_context(project_root, startup_cwd);
235        let (session, context_os) = match session_mode {
236            SessionMode::Personal => {
237                let mut session = if let Some(ref root) = startup.project_root {
238                    SessionState::load_latest_for_project_root(root).unwrap_or_default()
239                } else {
240                    SessionState::load_latest().unwrap_or_default()
241                };
242                if let Some(ref root) = startup.project_root {
243                    session.project_root = Some(root.clone());
244                }
245                if let Some(ref cwd) = startup.shell_cwd {
246                    session.shell_cwd = Some(cwd.clone());
247                }
248                (Arc::new(RwLock::new(session)), None)
249            }
250            SessionMode::Shared => {
251                let Some(ref root) = startup.project_root else {
252                    // Shared mode without a project root is not useful; fall back to personal.
253                    return Self::new_with_startup(
254                        project_root,
255                        startup_cwd,
256                        SessionMode::Personal,
257                        workspace_id,
258                        channel_id,
259                    );
260                };
261                let rt = crate::core::context_os::runtime();
262                let session = rt
263                    .shared_sessions
264                    .get_or_load(root, workspace_id, channel_id);
265                // Ensure shell_cwd is refreshed (best-effort).
266                if let Some(ref cwd) = startup.shell_cwd {
267                    if let Ok(mut s) = session.try_write() {
268                        s.shell_cwd = Some(cwd.clone());
269                    }
270                }
271                (session, Some(rt))
272            }
273        };
274
275        Self {
276            cache: Arc::new(RwLock::new(SessionCache::new())),
277            session,
278            tool_calls: Arc::new(RwLock::new(Vec::new())),
279            call_count: Arc::new(AtomicUsize::new(0)),
280            cache_ttl_secs: ttl,
281            last_call: Arc::new(RwLock::new(Instant::now())),
282            agent_id: Arc::new(RwLock::new(None)),
283            client_name: Arc::new(RwLock::new(String::new())),
284            autonomy: Arc::new(autonomy::AutonomyState::new()),
285            loop_detector: Arc::new(RwLock::new(
286                crate::core::loop_detection::LoopDetector::with_config(
287                    &crate::core::config::Config::load().loop_detection,
288                ),
289            )),
290            workflow: Arc::new(RwLock::new(
291                crate::core::workflow::load_active().ok().flatten(),
292            )),
293            ledger: Arc::new(RwLock::new(
294                crate::core::context_ledger::ContextLedger::new(),
295            )),
296            pipeline_stats: Arc::new(RwLock::new(crate::core::pipeline::PipelineStats::new())),
297            session_mode,
298            workspace_id: if workspace_id.trim().is_empty() {
299                "default".to_string()
300            } else {
301                workspace_id.trim().to_string()
302            },
303            channel_id: if channel_id.trim().is_empty() {
304                "default".to_string()
305            } else {
306                channel_id.trim().to_string()
307            },
308            context_os,
309            context_ir: None,
310            registry: None,
311            startup_project_root: startup.project_root,
312            startup_shell_cwd: startup.shell_cwd,
313        }
314    }
315
316    pub fn checkpoint_interval_effective() -> usize {
317        if let Ok(v) = std::env::var("LEAN_CTX_CHECKPOINT_INTERVAL") {
318            if let Ok(parsed) = v.trim().parse::<usize>() {
319                return parsed;
320            }
321        }
322        let profile_interval = crate::core::profiles::active_profile()
323            .autonomy
324            .checkpoint_interval_effective();
325        if profile_interval > 0 {
326            return profile_interval as usize;
327        }
328        crate::core::config::Config::load().checkpoint_interval as usize
329    }
330
331    /// Resolves a (possibly relative) tool path against the session's project_root.
332    /// Absolute paths and "." are returned as-is. Relative paths like "src/main.rs"
333    /// are joined with project_root so tools work regardless of the server's cwd.
334    pub async fn resolve_path(&self, path: &str) -> Result<String, String> {
335        let normalized = crate::hooks::normalize_tool_path(path);
336        if normalized.is_empty() || normalized == "." {
337            return Ok(normalized);
338        }
339        let p = std::path::Path::new(&normalized);
340
341        let (resolved, jail_root) = {
342            let session = self.session.read().await;
343            let jail_root = session
344                .project_root
345                .as_deref()
346                .or(session.shell_cwd.as_deref())
347                .unwrap_or(".")
348                .to_string();
349
350            let resolved = if p.is_absolute() || p.exists() {
351                std::path::PathBuf::from(&normalized)
352            } else if let Some(ref root) = session.project_root {
353                let joined = std::path::Path::new(root).join(&normalized);
354                if joined.exists() {
355                    joined
356                } else if let Some(ref cwd) = session.shell_cwd {
357                    std::path::Path::new(cwd).join(&normalized)
358                } else {
359                    std::path::Path::new(&jail_root).join(&normalized)
360                }
361            } else if let Some(ref cwd) = session.shell_cwd {
362                std::path::Path::new(cwd).join(&normalized)
363            } else {
364                std::path::Path::new(&jail_root).join(&normalized)
365            };
366
367            (resolved, jail_root)
368        };
369
370        let jail_root_path = std::path::Path::new(&jail_root);
371        let jailed = match crate::core::pathjail::jail_path(&resolved, jail_root_path) {
372            Ok(p) => p,
373            Err(e) => {
374                if p.is_absolute() {
375                    if let Some(new_root) = maybe_derive_project_root_from_absolute(&resolved) {
376                        let candidate_under_jail = resolved.starts_with(jail_root_path);
377                        let allow_reroot = if candidate_under_jail {
378                            false
379                        } else if let Some(ref trusted_root) = self.startup_project_root {
380                            std::path::Path::new(trusted_root) == new_root.as_path()
381                        } else {
382                            !has_project_marker(jail_root_path)
383                                || is_suspicious_root(jail_root_path)
384                        };
385
386                        if allow_reroot {
387                            let mut session = self.session.write().await;
388                            let new_root_str = new_root.to_string_lossy().to_string();
389                            session.project_root = Some(new_root_str.clone());
390                            session.shell_cwd = self
391                                .startup_shell_cwd
392                                .as_ref()
393                                .filter(|cwd| std::path::Path::new(cwd).starts_with(&new_root))
394                                .cloned()
395                                .or_else(|| Some(new_root_str.clone()));
396                            let _ = session.save();
397
398                            crate::core::pathjail::jail_path(&resolved, &new_root)?
399                        } else {
400                            return Err(e);
401                        }
402                    } else {
403                        return Err(e);
404                    }
405                } else {
406                    return Err(e);
407                }
408            }
409        };
410
411        Ok(crate::hooks::normalize_tool_path(
412            &jailed.to_string_lossy().replace('\\', "/"),
413        ))
414    }
415
416    /// Like `resolve_path`, but returns the original path on failure instead of an error.
417    pub async fn resolve_path_or_passthrough(&self, path: &str) -> String {
418        self.resolve_path(path)
419            .await
420            .unwrap_or_else(|_| path.to_string())
421    }
422
423    /// Clears the cache and saves the session if the TTL idle threshold has been exceeded.
424    pub async fn check_idle_expiry(&self) {
425        if self.cache_ttl_secs == 0 {
426            return;
427        }
428        let last = *self.last_call.read().await;
429        if last.elapsed().as_secs() >= self.cache_ttl_secs {
430            {
431                let mut session = self.session.write().await;
432                let _ = session.save();
433            }
434            let mut cache = self.cache.write().await;
435            let count = cache.clear();
436            if count > 0 {
437                tracing::info!(
438                    "Cache auto-cleared after {}s idle ({count} file(s))",
439                    self.cache_ttl_secs
440                );
441            }
442        }
443        *self.last_call.write().await = Instant::now();
444    }
445
446    /// Records a tool call's token savings without timing information.
447    pub async fn record_call(
448        &self,
449        tool: &str,
450        original: usize,
451        saved: usize,
452        mode: Option<String>,
453    ) {
454        self.record_call_with_timing(tool, original, saved, mode, 0)
455            .await;
456    }
457
458    /// Records a tool call like `record_call`, but includes an optional file path for observability.
459    pub async fn record_call_with_path(
460        &self,
461        tool: &str,
462        original: usize,
463        saved: usize,
464        mode: Option<String>,
465        path: Option<&str>,
466    ) {
467        self.record_call_with_timing_inner(tool, original, saved, mode, 0, path)
468            .await;
469    }
470
471    /// Records a tool call's token savings, duration, and emits events and stats.
472    pub async fn record_call_with_timing(
473        &self,
474        tool: &str,
475        original: usize,
476        saved: usize,
477        mode: Option<String>,
478        duration_ms: u64,
479    ) {
480        self.record_call_with_timing_inner(tool, original, saved, mode, duration_ms, None)
481            .await;
482    }
483
484    async fn record_call_with_timing_inner(
485        &self,
486        tool: &str,
487        original: usize,
488        saved: usize,
489        mode: Option<String>,
490        duration_ms: u64,
491        path: Option<&str>,
492    ) {
493        let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
494        let mut calls = self.tool_calls.write().await;
495        calls.push(ToolCallRecord {
496            tool: tool.to_string(),
497            original_tokens: original,
498            saved_tokens: saved,
499            mode: mode.clone(),
500            duration_ms,
501            timestamp: ts.clone(),
502        });
503
504        if duration_ms > 0 {
505            Self::append_tool_call_log(tool, duration_ms, original, saved, mode.as_deref(), &ts);
506        }
507
508        crate::core::events::emit_tool_call(
509            tool,
510            original as u64,
511            saved as u64,
512            mode.clone(),
513            duration_ms,
514            path.map(ToString::to_string),
515        );
516
517        let output_tokens = original.saturating_sub(saved);
518        crate::core::stats::record(tool, original, output_tokens);
519
520        let mut session = self.session.write().await;
521        session.record_tool_call(saved as u64, original as u64);
522        if tool == "ctx_shell" {
523            session.record_command();
524        }
525        let pending_save = if session.should_save() {
526            session.prepare_save().ok()
527        } else {
528            None
529        };
530        drop(calls);
531        drop(session);
532
533        if let Some(prepared) = pending_save {
534            tokio::task::spawn_blocking(move || {
535                let _ = prepared.write_to_disk();
536            });
537        }
538
539        self.write_mcp_live_stats().await;
540    }
541
542    /// Returns true if over an hour has passed since the last tool call.
543    pub async fn is_prompt_cache_stale(&self) -> bool {
544        let last = *self.last_call.read().await;
545        last.elapsed().as_secs() > 3600
546    }
547
548    /// Promotes lightweight read modes to richer ones when the prompt cache is stale.
549    pub fn upgrade_mode_if_stale(mode: &str, stale: bool) -> &str {
550        if !stale {
551            return mode;
552        }
553        match mode {
554            "full" => "full",
555            "map" => "signatures",
556            m => m,
557        }
558    }
559
560    /// Increments the call counter and returns true if a checkpoint is due.
561    pub fn increment_and_check(&self) -> bool {
562        let count = self.call_count.fetch_add(1, Ordering::Relaxed) + 1;
563        let interval = Self::checkpoint_interval_effective();
564        interval > 0 && count.is_multiple_of(interval)
565    }
566
567    /// Generates a compressed context checkpoint with session state and multi-agent sync.
568    pub async fn auto_checkpoint(&self) -> Option<String> {
569        let cache = self.cache.read().await;
570        if cache.get_all_entries().is_empty() {
571            return None;
572        }
573        let complexity = crate::core::adaptive::classify_from_context(&cache);
574        let checkpoint = ctx_compress::handle(&cache, true, CrpMode::effective());
575        drop(cache);
576
577        let mut session = self.session.write().await;
578        let _ = session.save();
579        let session_summary = session.format_compact();
580        let has_insights = !session.findings.is_empty() || !session.decisions.is_empty();
581        let project_root = session.project_root.clone();
582        drop(session);
583
584        if has_insights {
585            if let Some(ref root) = project_root {
586                let root = root.clone();
587                std::thread::spawn(move || {
588                    auto_consolidate_knowledge(&root);
589                });
590            }
591        }
592
593        let multi_agent_block = self
594            .auto_multi_agent_checkpoint(project_root.as_ref())
595            .await;
596
597        self.record_call("ctx_compress", 0, 0, Some("auto".to_string()))
598            .await;
599
600        self.record_cep_snapshot().await;
601
602        Some(format!(
603            "{checkpoint}\n\n--- SESSION STATE ---\n{session_summary}\n\n{}{multi_agent_block}",
604            complexity.instruction_suffix()
605        ))
606    }
607
608    async fn auto_multi_agent_checkpoint(&self, project_root: Option<&String>) -> String {
609        let Some(root) = project_root else {
610            return String::new();
611        };
612
613        let registry = crate::core::agents::AgentRegistry::load_or_create();
614        let active = registry.list_active(Some(root));
615        if active.len() <= 1 {
616            return String::new();
617        }
618
619        let agent_id = self.agent_id.read().await;
620        let my_id = match agent_id.as_deref() {
621            Some(id) => id.to_string(),
622            None => return String::new(),
623        };
624        drop(agent_id);
625
626        let cache = self.cache.read().await;
627        let entries = cache.get_all_entries();
628        if !entries.is_empty() {
629            let mut by_access: Vec<_> = entries.iter().collect();
630            by_access.sort_by_key(|x| std::cmp::Reverse(x.1.read_count));
631            let top_paths: Vec<&str> = by_access
632                .iter()
633                .take(5)
634                .map(|(key, _)| key.as_str())
635                .collect();
636            let paths_csv = top_paths.join(",");
637
638            let _ = ctx_share::handle("push", Some(&my_id), None, Some(&paths_csv), None, &cache);
639        }
640        drop(cache);
641
642        let pending_count = registry
643            .scratchpad
644            .iter()
645            .filter(|e| !e.read_by.contains(&my_id) && e.from_agent != my_id)
646            .count();
647
648        let shared_dir = crate::core::data_dir::lean_ctx_data_dir()
649            .unwrap_or_default()
650            .join("agents")
651            .join("shared");
652        let shared_count = if shared_dir.exists() {
653            std::fs::read_dir(&shared_dir).map_or(0, std::iter::Iterator::count)
654        } else {
655            0
656        };
657
658        let agent_names: Vec<String> = active
659            .iter()
660            .map(|a| {
661                let role = a.role.as_deref().unwrap_or(&a.agent_type);
662                format!("{role}({})", &a.agent_id[..8.min(a.agent_id.len())])
663            })
664            .collect();
665
666        format!(
667            "\n\n--- MULTI-AGENT SYNC ---\nAgents: {} | Pending msgs: {} | Shared contexts: {}\nAuto-shared top-5 cached files.\n--- END SYNC ---",
668            agent_names.join(", "),
669            pending_count,
670            shared_count,
671        )
672    }
673
674    /// Appends a tool call entry to the rotating `tool-calls.log` file.
675    pub fn append_tool_call_log(
676        tool: &str,
677        duration_ms: u64,
678        original: usize,
679        saved: usize,
680        mode: Option<&str>,
681        timestamp: &str,
682    ) {
683        const MAX_LOG_LINES: usize = 50;
684        if let Ok(dir) = crate::core::data_dir::lean_ctx_data_dir() {
685            let log_path = dir.join("tool-calls.log");
686            let mode_str = mode.unwrap_or("-");
687            let slow = if duration_ms > 5000 { " **SLOW**" } else { "" };
688            let line = format!(
689                "{timestamp}\t{tool}\t{duration_ms}ms\torig={original}\tsaved={saved}\tmode={mode_str}{slow}\n"
690            );
691
692            let mut lines: Vec<String> = std::fs::read_to_string(&log_path)
693                .unwrap_or_default()
694                .lines()
695                .map(std::string::ToString::to_string)
696                .collect();
697
698            lines.push(line.trim_end().to_string());
699            if lines.len() > MAX_LOG_LINES {
700                lines.drain(0..lines.len() - MAX_LOG_LINES);
701            }
702
703            let _ = std::fs::write(&log_path, lines.join("\n") + "\n");
704        }
705    }
706
707    fn compute_cep_stats(
708        calls: &[ToolCallRecord],
709        stats: &crate::core::cache::CacheStats,
710        complexity: &crate::core::adaptive::TaskComplexity,
711    ) -> CepComputedStats {
712        let total_original: u64 = calls.iter().map(|c| c.original_tokens as u64).sum();
713        let total_saved: u64 = calls.iter().map(|c| c.saved_tokens as u64).sum();
714        let total_compressed = total_original.saturating_sub(total_saved);
715        let compression_rate = if total_original > 0 {
716            total_saved as f64 / total_original as f64
717        } else {
718            0.0
719        };
720
721        let modes_used: std::collections::HashSet<&str> =
722            calls.iter().filter_map(|c| c.mode.as_deref()).collect();
723        let mode_diversity = (modes_used.len() as f64 / 10.0).min(1.0);
724        let cache_util = stats.hit_rate() / 100.0;
725        let cep_score = cache_util * 0.3 + mode_diversity * 0.2 + compression_rate * 0.5;
726
727        let mut mode_counts: std::collections::HashMap<String, u64> =
728            std::collections::HashMap::new();
729        for call in calls {
730            if let Some(ref mode) = call.mode {
731                *mode_counts.entry(mode.clone()).or_insert(0) += 1;
732            }
733        }
734
735        CepComputedStats {
736            cep_score: (cep_score * 100.0).round() as u32,
737            cache_util: (cache_util * 100.0).round() as u32,
738            mode_diversity: (mode_diversity * 100.0).round() as u32,
739            compression_rate: (compression_rate * 100.0).round() as u32,
740            total_original,
741            total_compressed,
742            total_saved,
743            mode_counts,
744            complexity: format!("{complexity:?}"),
745            cache_hits: stats.cache_hits,
746            total_reads: stats.total_reads,
747            tool_call_count: calls.len() as u64,
748        }
749    }
750
751    async fn write_mcp_live_stats(&self) {
752        let count = self.call_count.load(Ordering::Relaxed);
753        if count > 1 && !count.is_multiple_of(5) {
754            return;
755        }
756
757        let cache = self.cache.read().await;
758        let calls = self.tool_calls.read().await;
759        let stats = cache.get_stats();
760        let complexity = crate::core::adaptive::classify_from_context(&cache);
761
762        let cs = Self::compute_cep_stats(&calls, stats, &complexity);
763        let started_at = calls
764            .first()
765            .map(|c| c.timestamp.clone())
766            .unwrap_or_default();
767
768        drop(cache);
769        drop(calls);
770        let live = serde_json::json!({
771            "cep_score": cs.cep_score,
772            "cache_utilization": cs.cache_util,
773            "mode_diversity": cs.mode_diversity,
774            "compression_rate": cs.compression_rate,
775            "task_complexity": cs.complexity,
776            "files_cached": cs.total_reads,
777            "total_reads": cs.total_reads,
778            "cache_hits": cs.cache_hits,
779            "tokens_saved": cs.total_saved,
780            "tokens_original": cs.total_original,
781            "tool_calls": cs.tool_call_count,
782            "started_at": started_at,
783            "updated_at": chrono::Local::now().to_rfc3339(),
784        });
785
786        if let Ok(dir) = crate::core::data_dir::lean_ctx_data_dir() {
787            let _ = std::fs::write(dir.join("mcp-live.json"), live.to_string());
788        }
789    }
790
791    /// Persists a CEP (Context Efficiency Protocol) score snapshot for analytics.
792    pub async fn record_cep_snapshot(&self) {
793        let cache = self.cache.read().await;
794        let calls = self.tool_calls.read().await;
795        let stats = cache.get_stats();
796        let complexity = crate::core::adaptive::classify_from_context(&cache);
797
798        let cs = Self::compute_cep_stats(&calls, stats, &complexity);
799
800        drop(cache);
801        drop(calls);
802
803        crate::core::stats::record_cep_session(
804            cs.cep_score,
805            cs.cache_hits,
806            cs.total_reads,
807            cs.total_original,
808            cs.total_compressed,
809            &cs.mode_counts,
810            cs.tool_call_count,
811            &cs.complexity,
812        );
813    }
814}
815
816#[derive(Clone, Debug, Default)]
817struct StartupContext {
818    project_root: Option<String>,
819    shell_cwd: Option<String>,
820}
821
822/// Creates a new `LeanCtxServer` with default configuration.
823pub fn create_server() -> LeanCtxServer {
824    LeanCtxServer::new()
825}
826
827const PROJECT_ROOT_MARKERS: &[&str] = &[
828    ".git",
829    ".lean-ctx.toml",
830    "Cargo.toml",
831    "package.json",
832    "go.mod",
833    "pyproject.toml",
834    "pom.xml",
835    "build.gradle",
836    "Makefile",
837    ".planning",
838];
839
840fn has_project_marker(dir: &std::path::Path) -> bool {
841    PROJECT_ROOT_MARKERS.iter().any(|m| dir.join(m).exists())
842}
843
844fn is_suspicious_root(dir: &std::path::Path) -> bool {
845    let s = dir.to_string_lossy();
846    s.contains("/.claude")
847        || s.contains("/.codex")
848        || s.contains("\\.claude")
849        || s.contains("\\.codex")
850}
851
852fn canonicalize_path(path: &std::path::Path) -> String {
853    crate::core::pathutil::safe_canonicalize_or_self(path)
854        .to_string_lossy()
855        .to_string()
856}
857
858fn detect_startup_context(
859    explicit_project_root: Option<&str>,
860    startup_cwd: Option<&std::path::Path>,
861) -> StartupContext {
862    let shell_cwd = startup_cwd.map(canonicalize_path);
863    let project_root = explicit_project_root
864        .map(|root| canonicalize_path(std::path::Path::new(root)))
865        .or_else(|| {
866            startup_cwd
867                .and_then(maybe_derive_project_root_from_absolute)
868                .map(|p| canonicalize_path(&p))
869        });
870
871    let shell_cwd = match (shell_cwd, project_root.as_ref()) {
872        (Some(cwd), Some(root))
873            if std::path::Path::new(&cwd).starts_with(std::path::Path::new(root)) =>
874        {
875            Some(cwd)
876        }
877        (_, Some(root)) => Some(root.clone()),
878        (cwd, None) => cwd,
879    };
880
881    StartupContext {
882        project_root,
883        shell_cwd,
884    }
885}
886
887fn maybe_derive_project_root_from_absolute(abs: &std::path::Path) -> Option<std::path::PathBuf> {
888    let mut cur = if abs.is_dir() {
889        abs.to_path_buf()
890    } else {
891        abs.parent()?.to_path_buf()
892    };
893    loop {
894        if has_project_marker(&cur) {
895            return Some(crate::core::pathutil::safe_canonicalize_or_self(&cur));
896        }
897        if !cur.pop() {
898            break;
899        }
900    }
901    None
902}
903
904fn auto_consolidate_knowledge(project_root: &str) {
905    use crate::core::knowledge::ProjectKnowledge;
906    use crate::core::session::SessionState;
907
908    let Some(session) = SessionState::load_latest() else {
909        return;
910    };
911
912    if session.findings.is_empty() && session.decisions.is_empty() {
913        return;
914    }
915
916    let Ok(policy) = crate::core::config::Config::load().memory_policy_effective() else {
917        return;
918    };
919    let mut knowledge = ProjectKnowledge::load_or_create(project_root);
920
921    for finding in &session.findings {
922        let key = if let Some(ref file) = finding.file {
923            if let Some(line) = finding.line {
924                format!("{file}:{line}")
925            } else {
926                file.clone()
927            }
928        } else {
929            "finding-auto".to_string()
930        };
931        knowledge.remember("finding", &key, &finding.summary, &session.id, 0.7, &policy);
932    }
933
934    for decision in &session.decisions {
935        let key = decision
936            .summary
937            .chars()
938            .take(50)
939            .collect::<String>()
940            .replace(' ', "-")
941            .to_lowercase();
942        knowledge.remember(
943            "decision",
944            &key,
945            &decision.summary,
946            &session.id,
947            0.85,
948            &policy,
949        );
950    }
951
952    let task_desc = session
953        .task
954        .as_ref()
955        .map(|t| t.description.clone())
956        .unwrap_or_default();
957
958    let summary = format!(
959        "Auto-consolidate session {}: {} — {} findings, {} decisions",
960        session.id,
961        task_desc,
962        session.findings.len(),
963        session.decisions.len()
964    );
965    knowledge.consolidate(&summary, vec![session.id.clone()], &policy);
966    let _ = knowledge.save();
967}
968
969#[cfg(test)]
970mod resolve_path_tests {
971    use super::*;
972
973    fn create_git_root(path: &std::path::Path) -> String {
974        std::fs::create_dir_all(path.join(".git")).unwrap();
975        canonicalize_path(path)
976    }
977
978    #[tokio::test]
979    async fn resolve_path_can_reroot_to_trusted_startup_root_when_session_root_is_stale() {
980        let tmp = tempfile::tempdir().unwrap();
981        let stale = tmp.path().join("stale");
982        let real = tmp.path().join("real");
983        std::fs::create_dir_all(&stale).unwrap();
984        let real_root = create_git_root(&real);
985        std::fs::write(real.join("a.txt"), "ok").unwrap();
986
987        let server = LeanCtxServer::new_with_startup(
988            None,
989            Some(real.as_path()),
990            SessionMode::Personal,
991            "default",
992            "default",
993        );
994        {
995            let mut session = server.session.write().await;
996            session.project_root = Some(stale.to_string_lossy().to_string());
997            session.shell_cwd = Some(stale.to_string_lossy().to_string());
998        }
999
1000        let out = server
1001            .resolve_path(&real.join("a.txt").to_string_lossy())
1002            .await
1003            .unwrap();
1004
1005        assert!(out.ends_with("/a.txt"));
1006
1007        let session = server.session.read().await;
1008        assert_eq!(session.project_root.as_deref(), Some(real_root.as_str()));
1009        assert_eq!(session.shell_cwd.as_deref(), Some(real_root.as_str()));
1010    }
1011
1012    #[tokio::test]
1013    async fn resolve_path_rejects_absolute_path_outside_trusted_startup_root() {
1014        let tmp = tempfile::tempdir().unwrap();
1015        let stale = tmp.path().join("stale");
1016        let root = tmp.path().join("root");
1017        let other = tmp.path().join("other");
1018        std::fs::create_dir_all(&stale).unwrap();
1019        create_git_root(&root);
1020        let _other_value = create_git_root(&other);
1021        std::fs::write(other.join("b.txt"), "no").unwrap();
1022
1023        let server = LeanCtxServer::new_with_startup(
1024            None,
1025            Some(root.as_path()),
1026            SessionMode::Personal,
1027            "default",
1028            "default",
1029        );
1030        {
1031            let mut session = server.session.write().await;
1032            session.project_root = Some(stale.to_string_lossy().to_string());
1033            session.shell_cwd = Some(stale.to_string_lossy().to_string());
1034        }
1035
1036        let err = server
1037            .resolve_path(&other.join("b.txt").to_string_lossy())
1038            .await
1039            .unwrap_err();
1040        assert!(err.contains("path escapes project root"));
1041
1042        let session = server.session.read().await;
1043        assert_eq!(
1044            session.project_root.as_deref(),
1045            Some(stale.to_string_lossy().as_ref())
1046        );
1047    }
1048
1049    #[tokio::test]
1050    #[allow(clippy::await_holding_lock)]
1051    async fn startup_prefers_workspace_scoped_session_over_global_latest() {
1052        let _lock = crate::core::data_dir::test_env_lock();
1053        let _data = tempfile::tempdir().unwrap();
1054        let _tmp = tempfile::tempdir().unwrap();
1055
1056        std::env::set_var("LEAN_CTX_DATA_DIR", _data.path());
1057
1058        let repo_a = _tmp.path().join("repo-a");
1059        let repo_b = _tmp.path().join("repo-b");
1060        let root_a = create_git_root(&repo_a);
1061        let root_b = create_git_root(&repo_b);
1062
1063        let mut session_b = SessionState::new();
1064        session_b.project_root = Some(root_b.clone());
1065        session_b.shell_cwd = Some(root_b.clone());
1066        session_b.set_task("repo-b task", None);
1067        session_b.save().unwrap();
1068
1069        std::thread::sleep(std::time::Duration::from_millis(50));
1070
1071        let mut session_a = SessionState::new();
1072        session_a.project_root = Some(root_a.clone());
1073        session_a.shell_cwd = Some(root_a.clone());
1074        session_a.set_task("repo-a latest task", None);
1075        session_a.save().unwrap();
1076
1077        let server = LeanCtxServer::new_with_startup(
1078            None,
1079            Some(repo_b.as_path()),
1080            SessionMode::Personal,
1081            "default",
1082            "default",
1083        );
1084        std::env::remove_var("LEAN_CTX_DATA_DIR");
1085
1086        let session = server.session.read().await;
1087        assert_eq!(session.project_root.as_deref(), Some(root_b.as_str()));
1088        assert_eq!(session.shell_cwd.as_deref(), Some(root_b.as_str()));
1089        assert_eq!(
1090            session.task.as_ref().map(|t| t.description.as_str()),
1091            Some("repo-b task")
1092        );
1093    }
1094
1095    #[tokio::test]
1096    #[allow(clippy::await_holding_lock)]
1097    async fn startup_creates_fresh_session_for_new_workspace_and_preserves_subdir_cwd() {
1098        let _lock = crate::core::data_dir::test_env_lock();
1099        let _data = tempfile::tempdir().unwrap();
1100        let _tmp = tempfile::tempdir().unwrap();
1101
1102        std::env::set_var("LEAN_CTX_DATA_DIR", _data.path());
1103
1104        let repo_a = _tmp.path().join("repo-a");
1105        let repo_b = _tmp.path().join("repo-b");
1106        let repo_b_src = repo_b.join("src");
1107        let root_a = create_git_root(&repo_a);
1108        let root_b = create_git_root(&repo_b);
1109        std::fs::create_dir_all(&repo_b_src).unwrap();
1110        let repo_b_src_value = canonicalize_path(&repo_b_src);
1111
1112        let mut session_a = SessionState::new();
1113        session_a.project_root = Some(root_a.clone());
1114        session_a.shell_cwd = Some(root_a.clone());
1115        session_a.set_task("repo-a latest task", None);
1116        let old_id = session_a.id.clone();
1117        session_a.save().unwrap();
1118
1119        let server = LeanCtxServer::new_with_startup(
1120            None,
1121            Some(repo_b_src.as_path()),
1122            SessionMode::Personal,
1123            "default",
1124            "default",
1125        );
1126        std::env::remove_var("LEAN_CTX_DATA_DIR");
1127
1128        let session = server.session.read().await;
1129        assert_eq!(session.project_root.as_deref(), Some(root_b.as_str()));
1130        assert_eq!(
1131            session.shell_cwd.as_deref(),
1132            Some(repo_b_src_value.as_str())
1133        );
1134        assert!(session.task.is_none());
1135        assert_ne!(session.id, old_id);
1136    }
1137
1138    #[tokio::test]
1139    async fn resolve_path_does_not_auto_update_when_current_root_is_real_project() {
1140        let tmp = tempfile::tempdir().unwrap();
1141        let root = tmp.path().join("root");
1142        let other = tmp.path().join("other");
1143        let root_value = create_git_root(&root);
1144        create_git_root(&other);
1145        std::fs::write(other.join("b.txt"), "no").unwrap();
1146
1147        let root_str = root.to_string_lossy().to_string();
1148        let server = LeanCtxServer::new_with_project_root(Some(&root_str));
1149
1150        let err = server
1151            .resolve_path(&other.join("b.txt").to_string_lossy())
1152            .await
1153            .unwrap_err();
1154        assert!(err.contains("path escapes project root"));
1155
1156        let session = server.session.read().await;
1157        assert_eq!(session.project_root.as_deref(), Some(root_value.as_str()));
1158    }
1159}
lean_ctx/tools/mod.rs

lean_ctx/tools/
mod.rs
