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

lean_ctx/tools/
mod.rs
