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