1use std::path::PathBuf;
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_benchmark;
15pub mod ctx_callees;
16pub mod ctx_callers;
17pub mod ctx_compress;
18pub mod ctx_compress_memory;
19pub mod ctx_context;
20pub mod ctx_cost;
21pub mod ctx_dedup;
22pub mod ctx_delta;
23pub mod ctx_discover;
24pub mod ctx_edit;
25pub mod ctx_execute;
26pub mod ctx_expand;
27pub mod ctx_feedback;
28pub mod ctx_fill;
29pub mod ctx_gain;
30pub mod ctx_graph;
31pub mod ctx_graph_diagram;
32pub mod ctx_handoff;
33pub mod ctx_heatmap;
34pub mod ctx_impact;
35pub mod ctx_intent;
36pub mod ctx_knowledge;
37pub mod ctx_metrics;
38pub mod ctx_multi_read;
39pub mod ctx_outline;
40pub mod ctx_overview;
41pub mod ctx_prefetch;
42pub mod ctx_preload;
43pub mod ctx_read;
44pub mod ctx_response;
45pub mod ctx_routes;
46pub mod ctx_search;
47pub mod ctx_semantic_search;
48pub mod ctx_session;
49pub mod ctx_share;
50pub mod ctx_shell;
51pub mod ctx_smart_read;
52pub mod ctx_symbol;
53pub mod ctx_task;
54pub mod ctx_tree;
55pub mod ctx_workflow;
56pub mod ctx_wrapped;
57
58const DEFAULT_CACHE_TTL_SECS: u64 = 300;
59
60struct CepComputedStats {
61 cep_score: u32,
62 cache_util: u32,
63 mode_diversity: u32,
64 compression_rate: u32,
65 total_original: u64,
66 total_compressed: u64,
67 total_saved: u64,
68 mode_counts: std::collections::HashMap<String, u64>,
69 complexity: String,
70 cache_hits: u64,
71 total_reads: u64,
72 tool_call_count: u64,
73}
74
75#[derive(Clone, Copy, Debug, PartialEq, Eq)]
76pub enum CrpMode {
77 Off,
78 Compact,
79 Tdd,
80}
81
82impl CrpMode {
83 pub fn from_env() -> Self {
84 match std::env::var("LEAN_CTX_CRP_MODE")
85 .unwrap_or_default()
86 .to_lowercase()
87 .as_str()
88 {
89 "off" => Self::Off,
90 "compact" => Self::Compact,
91 _ => Self::Tdd,
92 }
93 }
94
95 pub fn is_tdd(&self) -> bool {
96 *self == Self::Tdd
97 }
98}
99
100pub type SharedCache = Arc<RwLock<SessionCache>>;
101
102#[derive(Clone)]
103pub struct LeanCtxServer {
104 pub cache: SharedCache,
105 pub session: Arc<RwLock<SessionState>>,
106 pub tool_calls: Arc<RwLock<Vec<ToolCallRecord>>>,
107 pub call_count: Arc<AtomicUsize>,
108 pub checkpoint_interval: usize,
109 pub cache_ttl_secs: u64,
110 pub last_call: Arc<RwLock<Instant>>,
111 pub crp_mode: CrpMode,
112 pub agent_id: Arc<RwLock<Option<String>>>,
113 pub client_name: Arc<RwLock<String>>,
114 pub autonomy: Arc<autonomy::AutonomyState>,
115 pub loop_detector: Arc<RwLock<crate::core::loop_detection::LoopDetector>>,
116 pub workflow: Arc<RwLock<Option<crate::core::workflow::WorkflowRun>>>,
117 pub ledger: Arc<RwLock<crate::core::context_ledger::ContextLedger>>,
118 pub pipeline_stats: Arc<RwLock<crate::core::pipeline::PipelineStats>>,
119 startup_project_root: Option<String>,
120 startup_shell_cwd: Option<String>,
121}
122
123#[derive(Clone, Debug)]
124pub struct ToolCallRecord {
125 pub tool: String,
126 pub original_tokens: usize,
127 pub saved_tokens: usize,
128 pub mode: Option<String>,
129 pub duration_ms: u64,
130 pub timestamp: String,
131}
132
133impl Default for LeanCtxServer {
134 fn default() -> Self {
135 Self::new()
136 }
137}
138
139impl LeanCtxServer {
140 pub fn new() -> Self {
141 Self::new_with_project_root(None)
142 }
143
144 pub fn new_with_project_root(project_root: Option<String>) -> Self {
145 Self::new_with_startup(project_root, std::env::current_dir().ok())
146 }
147
148 fn new_with_startup(project_root: Option<String>, startup_cwd: Option<PathBuf>) -> Self {
149 let config = crate::core::config::Config::load();
150
151 let interval = std::env::var("LEAN_CTX_CHECKPOINT_INTERVAL")
152 .ok()
153 .and_then(|v| v.parse().ok())
154 .unwrap_or(config.checkpoint_interval as usize);
155
156 let ttl = std::env::var("LEAN_CTX_CACHE_TTL")
157 .ok()
158 .and_then(|v| v.parse().ok())
159 .unwrap_or(DEFAULT_CACHE_TTL_SECS);
160
161 let crp_mode = CrpMode::from_env();
162
163 let startup = detect_startup_context(project_root.as_deref(), startup_cwd.as_deref());
164 let mut session = if let Some(ref root) = startup.project_root {
165 SessionState::load_latest_for_project_root(root).unwrap_or_default()
166 } else {
167 SessionState::load_latest().unwrap_or_default()
168 };
169
170 if let Some(ref root) = startup.project_root {
171 session.project_root = Some(root.clone());
172 }
173 if let Some(ref cwd) = startup.shell_cwd {
174 session.shell_cwd = Some(cwd.clone());
175 }
176
177 Self {
178 cache: Arc::new(RwLock::new(SessionCache::new())),
179 session: Arc::new(RwLock::new(session)),
180 tool_calls: Arc::new(RwLock::new(Vec::new())),
181 call_count: Arc::new(AtomicUsize::new(0)),
182 checkpoint_interval: interval,
183 cache_ttl_secs: ttl,
184 last_call: Arc::new(RwLock::new(Instant::now())),
185 crp_mode,
186 agent_id: Arc::new(RwLock::new(None)),
187 client_name: Arc::new(RwLock::new(String::new())),
188 autonomy: Arc::new(autonomy::AutonomyState::new()),
189 loop_detector: Arc::new(RwLock::new(
190 crate::core::loop_detection::LoopDetector::with_config(
191 &crate::core::config::Config::load().loop_detection,
192 ),
193 )),
194 workflow: Arc::new(RwLock::new(
195 crate::core::workflow::load_active().ok().flatten(),
196 )),
197 ledger: Arc::new(RwLock::new(
198 crate::core::context_ledger::ContextLedger::new(),
199 )),
200 pipeline_stats: Arc::new(RwLock::new(crate::core::pipeline::PipelineStats::new())),
201 startup_project_root: startup.project_root,
202 startup_shell_cwd: startup.shell_cwd,
203 }
204 }
205
206 pub async fn resolve_path(&self, path: &str) -> Result<String, String> {
210 let normalized = crate::hooks::normalize_tool_path(path);
211 if normalized.is_empty() || normalized == "." {
212 return Ok(normalized);
213 }
214 let p = std::path::Path::new(&normalized);
215
216 let (resolved, jail_root) = {
217 let session = self.session.read().await;
218 let jail_root = session
219 .project_root
220 .as_deref()
221 .or(session.shell_cwd.as_deref())
222 .unwrap_or(".")
223 .to_string();
224
225 let resolved = if p.is_absolute() || p.exists() {
226 std::path::PathBuf::from(&normalized)
227 } else if let Some(ref root) = session.project_root {
228 let joined = std::path::Path::new(root).join(&normalized);
229 if joined.exists() {
230 joined
231 } else if let Some(ref cwd) = session.shell_cwd {
232 std::path::Path::new(cwd).join(&normalized)
233 } else {
234 std::path::Path::new(&jail_root).join(&normalized)
235 }
236 } else if let Some(ref cwd) = session.shell_cwd {
237 std::path::Path::new(cwd).join(&normalized)
238 } else {
239 std::path::Path::new(&jail_root).join(&normalized)
240 };
241
242 (resolved, jail_root)
243 };
244
245 let jail_root_path = std::path::Path::new(&jail_root);
246 let jailed = match crate::core::pathjail::jail_path(&resolved, jail_root_path) {
247 Ok(p) => p,
248 Err(e) => {
249 if p.is_absolute() {
250 if let Some(new_root) = maybe_derive_project_root_from_absolute(&resolved) {
251 let candidate_under_jail = resolved.starts_with(jail_root_path);
252 let allow_reroot = if !candidate_under_jail {
253 if let Some(ref trusted_root) = self.startup_project_root {
254 std::path::Path::new(trusted_root) == new_root.as_path()
255 } else {
256 !has_project_marker(jail_root_path)
257 || is_suspicious_root(jail_root_path)
258 }
259 } else {
260 false
261 };
262
263 if allow_reroot {
264 let mut session = self.session.write().await;
265 let new_root_str = new_root.to_string_lossy().to_string();
266 session.project_root = Some(new_root_str.clone());
267 session.shell_cwd = self
268 .startup_shell_cwd
269 .as_ref()
270 .filter(|cwd| std::path::Path::new(cwd).starts_with(&new_root))
271 .cloned()
272 .or_else(|| Some(new_root_str.clone()));
273 let _ = session.save();
274
275 crate::core::pathjail::jail_path(&resolved, &new_root)?
276 } else {
277 return Err(e);
278 }
279 } else {
280 return Err(e);
281 }
282 } else {
283 return Err(e);
284 }
285 }
286 };
287
288 Ok(crate::hooks::normalize_tool_path(
289 &jailed.to_string_lossy().replace('\\', "/"),
290 ))
291 }
292
293 pub async fn resolve_path_or_passthrough(&self, path: &str) -> String {
294 self.resolve_path(path)
295 .await
296 .unwrap_or_else(|_| path.to_string())
297 }
298
299 pub async fn check_idle_expiry(&self) {
300 if self.cache_ttl_secs == 0 {
301 return;
302 }
303 let last = *self.last_call.read().await;
304 if last.elapsed().as_secs() >= self.cache_ttl_secs {
305 {
306 let mut session = self.session.write().await;
307 let _ = session.save();
308 }
309 let mut cache = self.cache.write().await;
310 let count = cache.clear();
311 if count > 0 {
312 tracing::info!(
313 "Cache auto-cleared after {}s idle ({count} file(s))",
314 self.cache_ttl_secs
315 );
316 }
317 }
318 *self.last_call.write().await = Instant::now();
319 }
320
321 pub async fn record_call(
322 &self,
323 tool: &str,
324 original: usize,
325 saved: usize,
326 mode: Option<String>,
327 ) {
328 self.record_call_with_timing(tool, original, saved, mode, 0)
329 .await;
330 }
331
332 pub async fn record_call_with_timing(
333 &self,
334 tool: &str,
335 original: usize,
336 saved: usize,
337 mode: Option<String>,
338 duration_ms: u64,
339 ) {
340 let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
341 let mut calls = self.tool_calls.write().await;
342 calls.push(ToolCallRecord {
343 tool: tool.to_string(),
344 original_tokens: original,
345 saved_tokens: saved,
346 mode: mode.clone(),
347 duration_ms,
348 timestamp: ts.clone(),
349 });
350
351 if duration_ms > 0 {
352 Self::append_tool_call_log(tool, duration_ms, original, saved, mode.as_deref(), &ts);
353 }
354
355 crate::core::events::emit_tool_call(
356 tool,
357 original as u64,
358 saved as u64,
359 mode.clone(),
360 duration_ms,
361 None,
362 );
363
364 let output_tokens = original.saturating_sub(saved);
365 crate::core::stats::record(tool, original, output_tokens);
366
367 let mut session = self.session.write().await;
368 session.record_tool_call(saved as u64, original as u64);
369 if tool == "ctx_shell" {
370 session.record_command();
371 }
372 if session.should_save() {
373 let _ = session.save();
374 }
375 drop(calls);
376 drop(session);
377
378 self.write_mcp_live_stats().await;
379 }
380
381 pub async fn is_prompt_cache_stale(&self) -> bool {
382 let last = *self.last_call.read().await;
383 last.elapsed().as_secs() > 3600
384 }
385
386 pub fn upgrade_mode_if_stale(mode: &str, stale: bool) -> &str {
387 if !stale {
388 return mode;
389 }
390 match mode {
391 "full" => "full",
392 "map" => "signatures",
393 m => m,
394 }
395 }
396
397 pub fn increment_and_check(&self) -> bool {
398 let count = self.call_count.fetch_add(1, Ordering::Relaxed) + 1;
399 self.checkpoint_interval > 0 && count.is_multiple_of(self.checkpoint_interval)
400 }
401
402 pub async fn auto_checkpoint(&self) -> Option<String> {
403 let cache = self.cache.read().await;
404 if cache.get_all_entries().is_empty() {
405 return None;
406 }
407 let complexity = crate::core::adaptive::classify_from_context(&cache);
408 let checkpoint = ctx_compress::handle(&cache, true, self.crp_mode);
409 drop(cache);
410
411 let mut session = self.session.write().await;
412 let _ = session.save();
413 let session_summary = session.format_compact();
414 let has_insights = !session.findings.is_empty() || !session.decisions.is_empty();
415 let project_root = session.project_root.clone();
416 drop(session);
417
418 if has_insights {
419 if let Some(ref root) = project_root {
420 let root = root.clone();
421 std::thread::spawn(move || {
422 auto_consolidate_knowledge(&root);
423 });
424 }
425 }
426
427 let multi_agent_block = self.auto_multi_agent_checkpoint(&project_root).await;
428
429 self.record_call("ctx_compress", 0, 0, Some("auto".to_string()))
430 .await;
431
432 self.record_cep_snapshot().await;
433
434 Some(format!(
435 "{checkpoint}\n\n--- SESSION STATE ---\n{session_summary}\n\n{}{multi_agent_block}",
436 complexity.instruction_suffix()
437 ))
438 }
439
440 async fn auto_multi_agent_checkpoint(&self, project_root: &Option<String>) -> String {
441 let root = match project_root {
442 Some(r) => r,
443 None => return String::new(),
444 };
445
446 let registry = crate::core::agents::AgentRegistry::load_or_create();
447 let active = registry.list_active(Some(root));
448 if active.len() <= 1 {
449 return String::new();
450 }
451
452 let agent_id = self.agent_id.read().await;
453 let my_id = match agent_id.as_deref() {
454 Some(id) => id.to_string(),
455 None => return String::new(),
456 };
457 drop(agent_id);
458
459 let cache = self.cache.read().await;
460 let entries = cache.get_all_entries();
461 if !entries.is_empty() {
462 let mut by_access: Vec<_> = entries.iter().collect();
463 by_access.sort_by_key(|x| std::cmp::Reverse(x.1.read_count));
464 let top_paths: Vec<&str> = by_access
465 .iter()
466 .take(5)
467 .map(|(key, _)| key.as_str())
468 .collect();
469 let paths_csv = top_paths.join(",");
470
471 let _ = ctx_share::handle("push", Some(&my_id), None, Some(&paths_csv), None, &cache);
472 }
473 drop(cache);
474
475 let pending_count = registry
476 .scratchpad
477 .iter()
478 .filter(|e| !e.read_by.contains(&my_id) && e.from_agent != my_id)
479 .count();
480
481 let shared_dir = crate::core::data_dir::lean_ctx_data_dir()
482 .unwrap_or_default()
483 .join("agents")
484 .join("shared");
485 let shared_count = if shared_dir.exists() {
486 std::fs::read_dir(&shared_dir)
487 .map(|rd| rd.count())
488 .unwrap_or(0)
489 } else {
490 0
491 };
492
493 let agent_names: Vec<String> = active
494 .iter()
495 .map(|a| {
496 let role = a.role.as_deref().unwrap_or(&a.agent_type);
497 format!("{role}({})", &a.agent_id[..8.min(a.agent_id.len())])
498 })
499 .collect();
500
501 format!(
502 "\n\n--- MULTI-AGENT SYNC ---\nAgents: {} | Pending msgs: {} | Shared contexts: {}\nAuto-shared top-5 cached files.\n--- END SYNC ---",
503 agent_names.join(", "),
504 pending_count,
505 shared_count,
506 )
507 }
508
509 pub fn append_tool_call_log(
510 tool: &str,
511 duration_ms: u64,
512 original: usize,
513 saved: usize,
514 mode: Option<&str>,
515 timestamp: &str,
516 ) {
517 const MAX_LOG_LINES: usize = 50;
518 if let Ok(dir) = crate::core::data_dir::lean_ctx_data_dir() {
519 let log_path = dir.join("tool-calls.log");
520 let mode_str = mode.unwrap_or("-");
521 let slow = if duration_ms > 5000 { " **SLOW**" } else { "" };
522 let line = format!(
523 "{timestamp}\t{tool}\t{duration_ms}ms\torig={original}\tsaved={saved}\tmode={mode_str}{slow}\n"
524 );
525
526 let mut lines: Vec<String> = std::fs::read_to_string(&log_path)
527 .unwrap_or_default()
528 .lines()
529 .map(|l| l.to_string())
530 .collect();
531
532 lines.push(line.trim_end().to_string());
533 if lines.len() > MAX_LOG_LINES {
534 lines.drain(0..lines.len() - MAX_LOG_LINES);
535 }
536
537 let _ = std::fs::write(&log_path, lines.join("\n") + "\n");
538 }
539 }
540
541 fn compute_cep_stats(
542 calls: &[ToolCallRecord],
543 stats: &crate::core::cache::CacheStats,
544 complexity: &crate::core::adaptive::TaskComplexity,
545 ) -> CepComputedStats {
546 let total_original: u64 = calls.iter().map(|c| c.original_tokens as u64).sum();
547 let total_saved: u64 = calls.iter().map(|c| c.saved_tokens as u64).sum();
548 let total_compressed = total_original.saturating_sub(total_saved);
549 let compression_rate = if total_original > 0 {
550 total_saved as f64 / total_original as f64
551 } else {
552 0.0
553 };
554
555 let modes_used: std::collections::HashSet<&str> =
556 calls.iter().filter_map(|c| c.mode.as_deref()).collect();
557 let mode_diversity = (modes_used.len() as f64 / 10.0).min(1.0);
558 let cache_util = stats.hit_rate() / 100.0;
559 let cep_score = cache_util * 0.3 + mode_diversity * 0.2 + compression_rate * 0.5;
560
561 let mut mode_counts: std::collections::HashMap<String, u64> =
562 std::collections::HashMap::new();
563 for call in calls {
564 if let Some(ref mode) = call.mode {
565 *mode_counts.entry(mode.clone()).or_insert(0) += 1;
566 }
567 }
568
569 CepComputedStats {
570 cep_score: (cep_score * 100.0).round() as u32,
571 cache_util: (cache_util * 100.0).round() as u32,
572 mode_diversity: (mode_diversity * 100.0).round() as u32,
573 compression_rate: (compression_rate * 100.0).round() as u32,
574 total_original,
575 total_compressed,
576 total_saved,
577 mode_counts,
578 complexity: format!("{:?}", complexity),
579 cache_hits: stats.cache_hits,
580 total_reads: stats.total_reads,
581 tool_call_count: calls.len() as u64,
582 }
583 }
584
585 async fn write_mcp_live_stats(&self) {
586 let cache = self.cache.read().await;
587 let calls = self.tool_calls.read().await;
588 let stats = cache.get_stats();
589 let complexity = crate::core::adaptive::classify_from_context(&cache);
590
591 let cs = Self::compute_cep_stats(&calls, stats, &complexity);
592 let started_at = calls
593 .first()
594 .map(|c| c.timestamp.clone())
595 .unwrap_or_default();
596
597 drop(cache);
598 drop(calls);
599 let live = serde_json::json!({
600 "cep_score": cs.cep_score,
601 "cache_utilization": cs.cache_util,
602 "mode_diversity": cs.mode_diversity,
603 "compression_rate": cs.compression_rate,
604 "task_complexity": cs.complexity,
605 "files_cached": cs.total_reads,
606 "total_reads": cs.total_reads,
607 "cache_hits": cs.cache_hits,
608 "tokens_saved": cs.total_saved,
609 "tokens_original": cs.total_original,
610 "tool_calls": cs.tool_call_count,
611 "started_at": started_at,
612 "updated_at": chrono::Local::now().to_rfc3339(),
613 });
614
615 if let Ok(dir) = crate::core::data_dir::lean_ctx_data_dir() {
616 let _ = std::fs::write(dir.join("mcp-live.json"), live.to_string());
617 }
618 }
619
620 pub async fn record_cep_snapshot(&self) {
621 let cache = self.cache.read().await;
622 let calls = self.tool_calls.read().await;
623 let stats = cache.get_stats();
624 let complexity = crate::core::adaptive::classify_from_context(&cache);
625
626 let cs = Self::compute_cep_stats(&calls, stats, &complexity);
627
628 drop(cache);
629 drop(calls);
630
631 crate::core::stats::record_cep_session(
632 cs.cep_score,
633 cs.cache_hits,
634 cs.total_reads,
635 cs.total_original,
636 cs.total_compressed,
637 &cs.mode_counts,
638 cs.tool_call_count,
639 &cs.complexity,
640 );
641 }
642}
643
644#[derive(Clone, Debug, Default)]
645struct StartupContext {
646 project_root: Option<String>,
647 shell_cwd: Option<String>,
648}
649
650pub fn create_server() -> LeanCtxServer {
651 LeanCtxServer::new()
652}
653
654const PROJECT_ROOT_MARKERS: &[&str] = &[
655 ".git",
656 ".lean-ctx.toml",
657 "Cargo.toml",
658 "package.json",
659 "go.mod",
660 "pyproject.toml",
661 "pom.xml",
662 "build.gradle",
663 "Makefile",
664 ".planning",
665];
666
667fn has_project_marker(dir: &std::path::Path) -> bool {
668 PROJECT_ROOT_MARKERS.iter().any(|m| dir.join(m).exists())
669}
670
671fn is_suspicious_root(dir: &std::path::Path) -> bool {
672 let s = dir.to_string_lossy();
673 s.contains("/.claude")
674 || s.contains("/.codex")
675 || s.contains("\\.claude")
676 || s.contains("\\.codex")
677}
678
679fn canonicalize_path(path: &std::path::Path) -> String {
680 crate::core::pathutil::safe_canonicalize_or_self(path)
681 .to_string_lossy()
682 .to_string()
683}
684
685fn detect_startup_context(
686 explicit_project_root: Option<&str>,
687 startup_cwd: Option<&std::path::Path>,
688) -> StartupContext {
689 let shell_cwd = startup_cwd.map(canonicalize_path);
690 let project_root = explicit_project_root
691 .map(|root| canonicalize_path(std::path::Path::new(root)))
692 .or_else(|| {
693 startup_cwd
694 .and_then(maybe_derive_project_root_from_absolute)
695 .map(|p| canonicalize_path(&p))
696 });
697
698 let shell_cwd = match (shell_cwd, project_root.as_ref()) {
699 (Some(cwd), Some(root))
700 if std::path::Path::new(&cwd).starts_with(std::path::Path::new(root)) =>
701 {
702 Some(cwd)
703 }
704 (Some(_), Some(root)) => Some(root.clone()),
705 (Some(cwd), None) => Some(cwd),
706 (None, Some(root)) => Some(root.clone()),
707 (None, None) => None,
708 };
709
710 StartupContext {
711 project_root,
712 shell_cwd,
713 }
714}
715
716fn maybe_derive_project_root_from_absolute(abs: &std::path::Path) -> Option<std::path::PathBuf> {
717 let mut cur = if abs.is_dir() {
718 abs.to_path_buf()
719 } else {
720 abs.parent()?.to_path_buf()
721 };
722 loop {
723 if has_project_marker(&cur) {
724 return Some(crate::core::pathutil::safe_canonicalize_or_self(&cur));
725 }
726 if !cur.pop() {
727 break;
728 }
729 }
730 None
731}
732
733fn auto_consolidate_knowledge(project_root: &str) {
734 use crate::core::knowledge::ProjectKnowledge;
735 use crate::core::session::SessionState;
736
737 let session = match SessionState::load_latest() {
738 Some(s) => s,
739 None => return,
740 };
741
742 if session.findings.is_empty() && session.decisions.is_empty() {
743 return;
744 }
745
746 let mut knowledge = ProjectKnowledge::load_or_create(project_root);
747
748 for finding in &session.findings {
749 let key = if let Some(ref file) = finding.file {
750 if let Some(line) = finding.line {
751 format!("{file}:{line}")
752 } else {
753 file.clone()
754 }
755 } else {
756 "finding-auto".to_string()
757 };
758 knowledge.remember("finding", &key, &finding.summary, &session.id, 0.7);
759 }
760
761 for decision in &session.decisions {
762 let key = decision
763 .summary
764 .chars()
765 .take(50)
766 .collect::<String>()
767 .replace(' ', "-")
768 .to_lowercase();
769 knowledge.remember("decision", &key, &decision.summary, &session.id, 0.85);
770 }
771
772 let task_desc = session
773 .task
774 .as_ref()
775 .map(|t| t.description.clone())
776 .unwrap_or_default();
777
778 let summary = format!(
779 "Auto-consolidate session {}: {} — {} findings, {} decisions",
780 session.id,
781 task_desc,
782 session.findings.len(),
783 session.decisions.len()
784 );
785 knowledge.consolidate(&summary, vec![session.id.clone()]);
786 let _ = knowledge.save();
787}
788
789#[cfg(test)]
790mod resolve_path_tests {
791 use super::*;
792
793 fn create_git_root(path: &std::path::Path) -> String {
794 std::fs::create_dir_all(path.join(".git")).unwrap();
795 canonicalize_path(path)
796 }
797
798 #[tokio::test]
799 async fn resolve_path_can_reroot_to_trusted_startup_root_when_session_root_is_stale() {
800 let tmp = tempfile::tempdir().unwrap();
801 let stale = tmp.path().join("stale");
802 let real = tmp.path().join("real");
803 std::fs::create_dir_all(&stale).unwrap();
804 let real_root = create_git_root(&real);
805 std::fs::write(real.join("a.txt"), "ok").unwrap();
806
807 let server = LeanCtxServer::new_with_startup(None, Some(real.clone()));
808 {
809 let mut session = server.session.write().await;
810 session.project_root = Some(stale.to_string_lossy().to_string());
811 session.shell_cwd = Some(stale.to_string_lossy().to_string());
812 }
813
814 let out = server
815 .resolve_path(&real.join("a.txt").to_string_lossy())
816 .await
817 .unwrap();
818
819 assert!(out.ends_with("/a.txt"));
820
821 let session = server.session.read().await;
822 assert_eq!(session.project_root.as_deref(), Some(real_root.as_str()));
823 assert_eq!(session.shell_cwd.as_deref(), Some(real_root.as_str()));
824 }
825
826 #[tokio::test]
827 async fn resolve_path_rejects_absolute_path_outside_trusted_startup_root() {
828 let tmp = tempfile::tempdir().unwrap();
829 let stale = tmp.path().join("stale");
830 let root = tmp.path().join("root");
831 let other = tmp.path().join("other");
832 std::fs::create_dir_all(&stale).unwrap();
833 create_git_root(&root);
834 let _other_value = create_git_root(&other);
835 std::fs::write(other.join("b.txt"), "no").unwrap();
836
837 let server = LeanCtxServer::new_with_startup(None, Some(root.clone()));
838 {
839 let mut session = server.session.write().await;
840 session.project_root = Some(stale.to_string_lossy().to_string());
841 session.shell_cwd = Some(stale.to_string_lossy().to_string());
842 }
843
844 let err = server
845 .resolve_path(&other.join("b.txt").to_string_lossy())
846 .await
847 .unwrap_err();
848 assert!(err.contains("path escapes project root"));
849
850 let session = server.session.read().await;
851 assert_eq!(
852 session.project_root.as_deref(),
853 Some(stale.to_string_lossy().as_ref())
854 );
855 }
856
857 #[tokio::test]
858 async fn startup_prefers_workspace_scoped_session_over_global_latest() {
859 let _data = tempfile::tempdir().unwrap();
860 let _tmp = tempfile::tempdir().unwrap();
861
862 let (server, root_b) = {
863 let _lock = crate::core::data_dir::test_env_lock();
864 std::env::set_var("LEAN_CTX_DATA_DIR", _data.path());
865
866 let repo_a = _tmp.path().join("repo-a");
867 let repo_b = _tmp.path().join("repo-b");
868 let root_a = create_git_root(&repo_a);
869 let root_b = create_git_root(&repo_b);
870
871 let mut session_b = SessionState::new();
872 session_b.project_root = Some(root_b.clone());
873 session_b.shell_cwd = Some(root_b.clone());
874 session_b.set_task("repo-b task", None);
875 session_b.save().unwrap();
876
877 let mut session_a = SessionState::new();
878 session_a.project_root = Some(root_a.clone());
879 session_a.shell_cwd = Some(root_a.clone());
880 session_a.set_task("repo-a latest task", None);
881 session_a.save().unwrap();
882
883 let server = LeanCtxServer::new_with_startup(None, Some(repo_b.clone()));
884 std::env::remove_var("LEAN_CTX_DATA_DIR");
885 (server, root_b)
886 };
887
888 let session = server.session.read().await;
889 assert_eq!(session.project_root.as_deref(), Some(root_b.as_str()));
890 assert_eq!(session.shell_cwd.as_deref(), Some(root_b.as_str()));
891 assert_eq!(
892 session.task.as_ref().map(|t| t.description.as_str()),
893 Some("repo-b task")
894 );
895 }
896
897 #[tokio::test]
898 async fn startup_creates_fresh_session_for_new_workspace_and_preserves_subdir_cwd() {
899 let _data = tempfile::tempdir().unwrap();
900 let _tmp = tempfile::tempdir().unwrap();
901
902 let (server, root_b, repo_b_src_value, old_id) = {
903 let _lock = crate::core::data_dir::test_env_lock();
904 std::env::set_var("LEAN_CTX_DATA_DIR", _data.path());
905
906 let repo_a = _tmp.path().join("repo-a");
907 let repo_b = _tmp.path().join("repo-b");
908 let repo_b_src = repo_b.join("src");
909 let root_a = create_git_root(&repo_a);
910 let root_b = create_git_root(&repo_b);
911 std::fs::create_dir_all(&repo_b_src).unwrap();
912 let repo_b_src_value = canonicalize_path(&repo_b_src);
913
914 let mut session_a = SessionState::new();
915 session_a.project_root = Some(root_a.clone());
916 session_a.shell_cwd = Some(root_a.clone());
917 session_a.set_task("repo-a latest task", None);
918 let old_id = session_a.id.clone();
919 session_a.save().unwrap();
920
921 let server = LeanCtxServer::new_with_startup(None, Some(repo_b_src.clone()));
922 std::env::remove_var("LEAN_CTX_DATA_DIR");
923 (server, root_b, repo_b_src_value, old_id)
924 };
925
926 let session = server.session.read().await;
927 assert_eq!(session.project_root.as_deref(), Some(root_b.as_str()));
928 assert_eq!(
929 session.shell_cwd.as_deref(),
930 Some(repo_b_src_value.as_str())
931 );
932 assert!(session.task.is_none());
933 assert_ne!(session.id, old_id);
934 }
935
936 #[tokio::test]
937 async fn resolve_path_does_not_auto_update_when_current_root_is_real_project() {
938 let tmp = tempfile::tempdir().unwrap();
939 let root = tmp.path().join("root");
940 let other = tmp.path().join("other");
941 let root_value = create_git_root(&root);
942 create_git_root(&other);
943 std::fs::write(other.join("b.txt"), "no").unwrap();
944
945 let server = LeanCtxServer::new_with_project_root(Some(root.to_string_lossy().to_string()));
946
947 let err = server
948 .resolve_path(&other.join("b.txt").to_string_lossy())
949 .await
950 .unwrap_err();
951 assert!(err.contains("path escapes project root"));
952
953 let session = server.session.read().await;
954 assert_eq!(session.project_root.as_deref(), Some(root_value.as_str()));
955 }
956}