Skip to content

armgit / Wake

Public Imported from GitHub
0

All your AI agent sessions in one place — browse, search, resume. Rust + GPUI.

Rust
10.4 KB
Raw Blame
use super::parse_utils::*;
use super::sqlite_ro::{has_table, open_sqlite_ro, virtual_path};
use super::AgentAdapter;
use crate::models::*;
use anyhow::{anyhow, Result};
use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::Mutex;

/// Copilot CLI:`~/.copilot/session-store.db` 全明文 SQLite。
/// sessions(id,cwd,branch,summary) + turns(user_message,assistant_response)。
/// 无每会话文件,SessionFileRef 用虚拟路径,mtime 取行内 updated_at、
/// size 取 turns 正文总长,二者共同构成增量扫描的 dirty 判断。
pub struct CopilotAdapter {
    db: PathBuf,
    /// rows() 的全表聚合较贵,按库戳(`db_cache_stamp`)缓存一轮扫描内的重复调用
    /// (list_session_files 与 quick_meta 各调一次)
    rows_cache: Mutex<Option<(i64, Vec<CopilotRow>)>>,
    /// 指令文件(项目根下的)与自定义来源按指纹缓存,每轮扫描只 stat
    memories: super::MemoryCache,
    /// `~/.copilot`;自定义根直接给了库文件的没有
    home: Option<PathBuf>,
}

impl CopilotAdapter {
    pub fn new() -> Self {
        let home = super::home_dir().unwrap_or_default().join(".copilot");
        Self {
            db: home.join("session-store.db"),
            rows_cache: Mutex::new(None),
            memories: super::MemoryCache::new(),
            home: Some(home),
        }
    }

    fn db_stamp(&self) -> i64 {
        super::sqlite_ro::db_cache_stamp(&self.db)
    }

    fn rows(&self) -> Option<Vec<CopilotRow>> {
        let stamp = self.db_stamp();
        {
            let cache = self.rows_cache.lock().unwrap();
            if let Some((t, rows)) = cache.as_ref() {
                if *t == stamp {
                    return Some(rows.clone());
                }
            }
        }
        let ro = open_sqlite_ro(&self.db, "copilot")?;
        // 库在、表还没建 = 确实没有会话;读不出(None)才是不知道
        if !(has_table(&ro.conn, "sessions").ok()? && has_table(&ro.conn, "turns").ok()?) {
            *self.rows_cache.lock().unwrap() = Some((stamp, Vec::new()));
            return Some(Vec::new());
        }
        let mut stmt = ro
            .conn
            .prepare(
                "SELECT s.id, s.cwd, s.branch, s.summary, s.created_at, s.updated_at,
                        COALESCE(SUM(LENGTH(COALESCE(t.user_message,'')) + LENGTH(COALESCE(t.assistant_response,''))), 0),
                        COUNT(t.id)
                 FROM sessions s LEFT JOIN turns t ON t.session_id = s.id
                 GROUP BY s.id",
            )
            .ok()?;
        let rows = stmt
            .query_map([], |r| {
                Ok(CopilotRow {
                    id: r.get(0)?,
                    cwd: r.get::<_, Option<String>>(1)?.unwrap_or_default(),
                    branch: r.get(2)?,
                    summary: r.get::<_, Option<String>>(3)?.unwrap_or_default(),
                    created_ms: sqlite_dt_ms(&r.get::<_, Option<String>>(4)?.unwrap_or_default()),
                    updated_ms: sqlite_dt_ms(&r.get::<_, Option<String>>(5)?.unwrap_or_default()),
                    content_len: r.get(6)?,
                    turn_count: r.get(7)?,
                })
            })
            .ok()?
            .collect::<rusqlite::Result<Vec<_>>>()
            .ok()?;
        *self.rows_cache.lock().unwrap() = Some((stamp, rows.clone()));
        Some(rows)
    }

    fn build_meta(&self, r: &SessionFileRef, row: &CopilotRow, message_count: i64) -> SessionMeta {
        let title = clean_title_candidate(&row.summary);
        SessionMeta {
            key: format!("copilot:{}", row.id),
            host: String::new(),
            id: row.id.clone(),
            agent: AgentId::Copilot,
            title: if title.is_empty() {
                UNTITLED.to_string()
            } else {
                title
            },
            project_path: row.cwd.clone(),
            project_name: project_name_of(&row.cwd),
            file_path: r.file_path.clone(),
            created_at: if row.created_ms > 0 {
                row.created_ms
            } else {
                r.mtime_ms
            },
            updated_at: if row.updated_ms > 0 {
                row.updated_ms
            } else {
                r.mtime_ms
            },
            message_count,
            size_bytes: r.size,
            git_branch: row.branch.clone().filter(|b| !b.is_empty()),
            model: None,
            tokens_used: None,
            archived: false,
            source: None,
            spawned: false,
            favorite: false,
            pinned: false,
        }
    }

    /// 单会话解析:一次连接,会话行与 turns 都只查本会话(不做全表聚合)
    fn parse(&self, r: &SessionFileRef) -> Result<(SessionMeta, Vec<TranscriptMessage>)> {
        let ro = open_sqlite_ro(&self.db, "copilot")
            .ok_or_else(|| anyhow!("cannot open copilot store"))?;
        let row = ro
            .conn
            .query_row(
                "SELECT s.id, s.cwd, s.branch, s.summary, s.created_at, s.updated_at,
                        COALESCE(SUM(LENGTH(COALESCE(t.user_message,'')) + LENGTH(COALESCE(t.assistant_response,''))), 0),
                        COUNT(t.id)
                 FROM sessions s LEFT JOIN turns t ON t.session_id = s.id
                 WHERE s.id = ?1 GROUP BY s.id",
                [&r.native_id],
                |x| {
                    Ok(CopilotRow {
                        id: x.get(0)?,
                        cwd: x.get::<_, Option<String>>(1)?.unwrap_or_default(),
                        branch: x.get(2)?,
                        summary: x.get::<_, Option<String>>(3)?.unwrap_or_default(),
                        created_ms: sqlite_dt_ms(&x.get::<_, Option<String>>(4)?.unwrap_or_default()),
                        updated_ms: sqlite_dt_ms(&x.get::<_, Option<String>>(5)?.unwrap_or_default()),
                        content_len: x.get(6)?,
                        turn_count: x.get(7)?,
                    })
                },
            )
            .map_err(|_| anyhow!("copilot session {} not in store", r.native_id))?;

        let mut stmt = ro.conn.prepare(
            "SELECT user_message, assistant_response, timestamp
             FROM turns WHERE session_id = ?1 ORDER BY turn_index",
        )?;
        let turns = stmt.query_map([&r.native_id], |t| {
            Ok((
                t.get::<_, Option<String>>(0)?,
                t.get::<_, Option<String>>(1)?,
                t.get::<_, Option<String>>(2)?,
            ))
        })?;

        let mut messages: Vec<TranscriptMessage> = Vec::new();
        for turn in turns.flatten() {
            let ts = sqlite_dt_ms(&turn.2.unwrap_or_default());
            if let Some(u) = turn.0.filter(|s| !s.trim().is_empty()) {
                messages.push(text_msg(Role::User, &u, ts));
            }
            if let Some(a) = turn.1.filter(|s| !s.trim().is_empty()) {
                messages.push(text_msg(Role::Assistant, &a, ts));
            }
        }
        assign_seq(&mut messages);
        let count = messages
            .iter()
            .filter(|m| m.kind == MessageKind::Text)
            .count() as i64;
        let mut meta = self.build_meta(r, &row, count);
        // summary 缺失时回退首条用户消息
        if meta.title == UNTITLED {
            if let Some(t) = title_from_messages(&messages) {
                meta.title = t;
            }
        }
        Ok((meta, messages))
    }
}

#[derive(Clone)]
struct CopilotRow {
    id: String,
    cwd: String,
    branch: Option<String>,
    summary: String,
    created_ms: i64,
    updated_ms: i64,
    content_len: i64,
    turn_count: i64,
}

impl AgentAdapter for CopilotAdapter {
    fn agent(&self) -> AgentId {
        AgentId::Copilot
    }

    fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {
        // 库不在 = 没有会话;库在却读不出报 Err,scanner 冻结这一家这一轮(不变量 8①)——
        // 当成没有会话的话,这一轮会把整家会话当"磁盘已删"清掉
        if !self.db.is_file() {
            return Ok(Vec::new());
        }
        let rows = self
            .rows()
            .ok_or_else(|| anyhow!("{} exists but could not be read", self.db.display()))?;
        Ok(rows
            .into_iter()
            .filter(|row| row.turn_count > 0)
            .map(|row| SessionFileRef {
                agent: AgentId::Copilot,
                native_id: row.id.clone(),
                file_path: virtual_path(&self.db, &row.id),
                mtime_ms: row.updated_ms,
                size: row.content_len,
            })
            .collect())
    }

    fn quick_meta(&self, refs: &[SessionFileRef]) -> Option<HashMap<String, SessionMeta>> {
        let rows = self.rows()?;
        let by_id: HashMap<&str, &CopilotRow> = rows.iter().map(|r| (r.id.as_str(), r)).collect();
        let mut out = HashMap::new();
        for r in refs {
            if let Some(row) = by_id.get(r.native_id.as_str()) {
                out.insert(r.file_path.clone(), self.build_meta(r, row, 0));
            }
        }
        Some(out)
    }

    fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {
        let (meta, messages) = self.parse(r)?;
        Ok(ParsedSession::derive(meta, &messages, 0))
    }

    fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {
        let (meta, messages) = self.parse(r)?;
        Ok(ParsedTranscript {
            meta,
            mainline: messages,
            sidechains: Vec::new(),
            unknown_line_count: 0,
        })
    }

    fn list_memories(
        &self,
        sources: &[MemorySource],
        projects: &[PathBuf],
    ) -> Result<Vec<MemoryDoc>> {
        // 只有项目指令文件与用户加的自定义来源;trait 默认实现没处放缓存、每轮都重读
        super::generic_memory_docs(&self.memories, AgentId::Copilot, sources, projects)
    }

    fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {
        // 手输/预填的就是库文件路径时直接认,不再往下拼(Codex review)
        let (db, home) = if dir.is_file() {
            (dir, None)
        } else {
            (dir.join("session-store.db"), Some(dir))
        };
        Box::new(Self {
            db,
            rows_cache: Mutex::new(None),
            memories: super::MemoryCache::new(),
            home,
        })
    }

    fn data_roots(&self) -> Vec<PathBuf> {
        vec![self.db.clone()]
    }

    fn homes(&self) -> Vec<PathBuf> {
        self.home.iter().cloned().collect()
    }
}