agtrace_runtime/client/
sessions.rs

1use crate::ops::{
2    ExportService, IndexProgress, IndexService, ListSessionsRequest, PackResult, PackService,
3    SessionService,
4};
5use crate::storage::{RawFileContent, get_raw_files};
6use agtrace_engine::export::ExportStrategy;
7use agtrace_index::{Database, SessionSummary};
8use agtrace_providers::{ProviderAdapter, ScanContext};
9use agtrace_types::{AgentEvent, discover_project_root, project_hash_from_root};
10use anyhow::Result;
11use std::path::PathBuf;
12use std::sync::{Arc, Mutex};
13
14#[derive(Debug, Clone, Default)]
15pub struct SessionFilter {
16    pub project_hash: Option<String>,
17    pub limit: usize,
18    pub all_projects: bool,
19    pub provider: Option<String>,
20    pub since: Option<String>,
21    pub until: Option<String>,
22}
23
24impl SessionFilter {
25    pub fn new() -> Self {
26        Self {
27            limit: 100,
28            ..Default::default()
29        }
30    }
31
32    pub fn limit(mut self, limit: usize) -> Self {
33        self.limit = limit;
34        self
35    }
36
37    pub fn project(mut self, project_hash: String) -> Self {
38        self.project_hash = Some(project_hash);
39        self
40    }
41
42    pub fn all_projects(mut self) -> Self {
43        self.all_projects = true;
44        self
45    }
46
47    pub fn provider(mut self, provider: String) -> Self {
48        self.provider = Some(provider);
49        self
50    }
51
52    pub fn since(mut self, since: String) -> Self {
53        self.since = Some(since);
54        self
55    }
56
57    pub fn until(mut self, until: String) -> Self {
58        self.until = Some(until);
59        self
60    }
61}
62
63pub struct SessionOps {
64    db: Arc<Mutex<Database>>,
65    provider_configs: Arc<Vec<(String, PathBuf)>>,
66}
67
68impl SessionOps {
69    pub fn new(db: Arc<Mutex<Database>>, provider_configs: Arc<Vec<(String, PathBuf)>>) -> Self {
70        Self {
71            db,
72            provider_configs,
73        }
74    }
75
76    pub fn list(&self, filter: SessionFilter) -> Result<Vec<SessionSummary>> {
77        self.ensure_index_is_fresh()?;
78        self.list_without_refresh(filter)
79    }
80
81    pub fn list_without_refresh(&self, filter: SessionFilter) -> Result<Vec<SessionSummary>> {
82        let db = self.db.lock().unwrap();
83        let service = SessionService::new(&db);
84        let request = ListSessionsRequest {
85            project_hash: filter.project_hash,
86            limit: filter.limit,
87            all_projects: filter.all_projects,
88            provider: filter.provider,
89            since: filter.since,
90            until: filter.until,
91        };
92        service.list_sessions(request)
93    }
94
95    fn ensure_index_is_fresh(&self) -> Result<()> {
96        let db = self.db.lock().unwrap();
97
98        let providers: Vec<(ProviderAdapter, PathBuf)> = self
99            .provider_configs
100            .iter()
101            .filter_map(|(name, path)| {
102                agtrace_providers::create_adapter(name)
103                    .ok()
104                    .map(|p| (p, path.clone()))
105            })
106            .collect();
107
108        let service = IndexService::new(&db, providers);
109
110        // Scan all projects: project_root=None means no filtering
111        // project_hash is only used for reporting and as fallback
112        let project_hash = discover_project_root(None)
113            .ok()
114            .map(|root| project_hash_from_root(&root.display().to_string()))
115            .unwrap_or_else(|| "unknown".to_string());
116
117        let scan_context = ScanContext {
118            project_hash,
119            project_root: None,
120            provider_filter: None,
121        };
122
123        service.run(&scan_context, false, |_progress: IndexProgress| {})?;
124
125        Ok(())
126    }
127
128    pub fn find(&self, session_id: &str) -> Result<SessionHandle> {
129        if let Some(resolved_id) = self.resolve_session_id(session_id)? {
130            return Ok(SessionHandle {
131                id: resolved_id,
132                db: self.db.clone(),
133            });
134        }
135
136        self.ensure_index_is_fresh()?;
137
138        if let Some(resolved_id) = self.resolve_session_id(session_id)? {
139            return Ok(SessionHandle {
140                id: resolved_id,
141                db: self.db.clone(),
142            });
143        }
144
145        anyhow::bail!("Session not found: {}", session_id)
146    }
147
148    fn resolve_session_id(&self, session_id: &str) -> Result<Option<String>> {
149        let db = self.db.lock().unwrap();
150
151        if let Some(session) = db.get_session_by_id(session_id)? {
152            return Ok(Some(session.id));
153        }
154
155        db.find_session_by_prefix(session_id)
156    }
157
158    pub fn pack_context(&self, project_hash: Option<&str>, limit: usize) -> Result<PackResult> {
159        self.ensure_index_is_fresh()?;
160
161        let db = self.db.lock().unwrap();
162        let service = PackService::new(&db);
163        service.select_sessions(project_hash, limit)
164    }
165}
166
167pub struct SessionHandle {
168    id: String,
169    db: Arc<Mutex<Database>>,
170}
171
172impl SessionHandle {
173    pub fn events(&self) -> Result<Vec<AgentEvent>> {
174        let db = self.db.lock().unwrap();
175        let service = SessionService::new(&db);
176        service.get_session_events(&self.id)
177    }
178
179    pub fn raw_files(&self) -> Result<Vec<RawFileContent>> {
180        let db = self.db.lock().unwrap();
181        get_raw_files(&db, &self.id)
182    }
183
184    pub fn export(&self, strategy: ExportStrategy) -> Result<Vec<AgentEvent>> {
185        let db = self.db.lock().unwrap();
186        let service = ExportService::new(&db);
187        service.export_session(&self.id, strategy)
188    }
189
190    pub fn id(&self) -> &str {
191        &self.id
192    }
193}
agtrace_runtime/client/sessions.rs

agtrace_runtime/client/
sessions.rs
