Skip to content

armgit / Wake

Public Imported from GitHub
0

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

Rust
6.9 KB
Raw Blame
use super::parse_utils::*;
use super::AgentAdapter;
use crate::models::*;
use anyhow::Result;
use serde_json::Value;
use std::fs;
use std::io::BufReader;
use std::path::{Path, PathBuf};

/// Kiro CLI:`~/.kiro/sessions/cli/<uuid>.{jsonl,json,history}` 三件套。
/// .json 边车含 cwd/title/时间;.jsonl 行 {kind:Prompt|AssistantMessage,
/// data:{content:[{kind:text,data}],meta:{timestamp:unix秒}}};.history 忽略。
pub struct KiroAdapter {
    root: PathBuf,
    /// 指令文件(项目根下的)与自定义来源按指纹缓存,每轮扫描只 stat
    memories: super::MemoryCache,
    /// `~/.kiro`;选中 sessions 或 sessions/cli 的自定义根没有
    home: Option<PathBuf>,
}

impl KiroAdapter {
    pub fn new() -> Self {
        let home = super::home_dir().unwrap_or_default().join(".kiro");
        Self {
            root: home.join("sessions").join("cli"),
            memories: super::MemoryCache::new(),
            home: Some(home),
        }
    }
}

struct Sidecar {
    cwd: String,
    title: String,
    created_ms: i64,
    updated_ms: i64,
    model: Option<String>,
}

fn read_sidecar(jsonl_path: &Path) -> Sidecar {
    let mut side = Sidecar {
        cwd: String::new(),
        title: String::new(),
        created_ms: 0,
        updated_ms: 0,
        model: None,
    };
    let json_path = jsonl_path.with_extension("json");
    if let Ok(raw) = fs::read_to_string(&json_path) {
        if let Ok(v) = serde_json::from_str::<Value>(&raw) {
            if let Some(c) = v.get("cwd").and_then(|x| x.as_str()) {
                side.cwd = c.to_string();
            }
            if let Some(t) = v.get("title").and_then(|x| x.as_str()) {
                side.title = t.to_string();
            }
            if let Some(t) = v.get("created_at").and_then(|x| x.as_str()) {
                side.created_ms = iso_ms(t);
            }
            if let Some(t) = v.get("updated_at").and_then(|x| x.as_str()) {
                side.updated_ms = iso_ms(t);
            }
            side.model = v
                .pointer("/session_state/rts_model_state/model_info/model_id")
                .or_else(|| v.pointer("/session_state/rts_model_state/model_info/model_name"))
                .and_then(|x| x.as_str())
                .filter(|m| !m.is_empty())
                .map(String::from);
        }
    }
    side
}

fn parse_kiro_jsonl(path: &Path, decode_images: bool) -> Result<(Vec<TranscriptMessage>, u32)> {
    let _image_budget = transcript_image_decode_budget(decode_images);
    let file = fs::File::open(path)?;
    let reader = BufReader::with_capacity(1 << 20, file);
    let mut messages: Vec<TranscriptMessage> = Vec::new();
    let mut unknown = 0u32;

    for row in jsonl_values(reader) {
        let Some(row) = row? else {
            unknown += 1;
            continue;
        };
        let role = match row.get("kind").and_then(|v| v.as_str()) {
            Some("Prompt") => Role::User,
            Some("AssistantMessage") => Role::Assistant,
            _ => {
                unknown += 1;
                continue;
            }
        };
        let Some(data) = row.get("data") else {
            unknown += 1;
            continue;
        };
        let parsed = content_parts(data.get("content").unwrap_or(&Value::Null), decode_images);
        if parsed.text.is_empty() && parsed.images.is_empty() {
            continue;
        }
        let ts_sec = data
            .get("meta")
            .and_then(|m| m.get("timestamp"))
            .and_then(|v| v.as_i64())
            .unwrap_or(0);
        let mut message = text_msg(role, &parsed.text, ts_sec * 1000);
        message.images = parsed.images;
        messages.push(message);
    }
    assign_seq(&mut messages);
    Ok((messages, unknown))
}

fn build_meta(r: &SessionFileRef, side: &Sidecar, messages: &[TranscriptMessage]) -> SessionMeta {
    let title = session_title(&side.title, false, messages);
    let msg_ts_max = messages
        .iter()
        .filter_map(|m| m.timestamp)
        .max()
        .unwrap_or(0);
    SessionMeta {
        key: format!("kiro:{}", r.native_id),
        host: String::new(),
        id: r.native_id.clone(),
        agent: AgentId::Kiro,
        title,
        project_path: side.cwd.clone(),
        project_name: project_name_of(&side.cwd),
        file_path: r.file_path.clone(),
        created_at: if side.created_ms > 0 {
            side.created_ms
        } else {
            r.mtime_ms
        },
        updated_at: match side.updated_ms.max(msg_ts_max) {
            t if t > 0 => t,
            _ => r.mtime_ms,
        },
        message_count: messages
            .iter()
            .filter(|m| m.kind == MessageKind::Text)
            .count() as i64,
        size_bytes: r.size,
        git_branch: None,
        model: side.model.clone(),
        tokens_used: None,
        archived: false,
        source: None,
        spawned: false,
        favorite: false,
        pinned: false,
    }
}

impl AgentAdapter for KiroAdapter {
    fn agent(&self) -> AgentId {
        AgentId::Kiro
    }

    fn list_session_files(&self) -> Result<Vec<SessionFileRef>> {
        Ok(list_jsonl_refs(&self.root, AgentId::Kiro, str::to_string))
    }

    fn parse_session(&self, r: &SessionFileRef) -> Result<ParsedSession> {
        let (messages, unknown) = parse_kiro_jsonl(Path::new(&r.file_path), false)?;
        let side = read_sidecar(Path::new(&r.file_path));
        let meta = build_meta(r, &side, &messages);
        Ok(ParsedSession::derive(meta, &messages, unknown))
    }

    fn parse_transcript(&self, r: &SessionFileRef) -> Result<ParsedTranscript> {
        let (messages, unknown) = parse_kiro_jsonl(Path::new(&r.file_path), true)?;
        let side = read_sidecar(Path::new(&r.file_path));
        Ok(ParsedTranscript {
            meta: build_meta(r, &side, &messages),
            mainline: messages,
            sidechains: Vec::new(),
            unknown_line_count: unknown,
        })
    }

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

    fn with_custom_root(&self, dir: PathBuf) -> Box<dyn AgentAdapter> {
        // `~/.kiro`/`~/.kiro/sessions`/`~/.kiro/sessions/cli` 三层都认
        let (root, home) = if dir.join("sessions").join("cli").is_dir() {
            (dir.join("sessions").join("cli"), Some(dir))
        } else if dir.join("cli").is_dir() {
            (dir.join("cli"), None)
        } else {
            (dir, None)
        };
        Box::new(Self {
            root,
            memories: super::MemoryCache::new(),
            home,
        })
    }

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

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