magi-code 0.97.1

Repository-aware CLI coding agent for terminal work
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

//! Read-only, bounded inventory of primary durable session files.
use super::{Session, SessionManager};
use sha2::{Digest, Sha256};
use std::{collections::BTreeMap, os::unix::fs::MetadataExt};

impl SessionManager {
    pub(crate) fn validate_discovery_root(&self) -> Result<(), &'static str> {
        super::store::validate_session_root(&self.root).map_err(|_| "discovery_unavailable")
    }
    /// No leases, metadata repair, retention sweep or permission changes.
    pub(crate) fn discovery_inventory(
        &self,
        cancellation: &crate::cancellation::AgentCancellation,
    ) -> Result<(Vec<Session>, [u8; 32]), &'static str> {
        super::store::validate_session_root(&self.root).map_err(|_| "discovery_unavailable")?;
        let mut files = BTreeMap::new();
        for (index, entry) in std::fs::read_dir(&self.root)
            .map_err(|_| "discovery_unavailable")?
            .enumerate()
        {
            cancellation.check().map_err(|_| "operation_cancelled")?;
            if index == 4096 {
                return Err("discovery_limit");
            }
            let entry = entry.map_err(|_| "discovery_unavailable")?;
            let metadata = std::fs::symlink_metadata(entry.path()).map_err(|_| "stale_revision")?;
            // Lock renewal must not invalidate pages; existence still changes revision.
            let name = entry.file_name();
            let lock = name.to_string_lossy().ends_with(".lock");
            files.insert(
                name,
                (
                    metadata.dev(),
                    metadata.ino(),
                    metadata.mode(),
                    metadata.uid(),
                    metadata.nlink(),
                    if lock { 0 } else { metadata.len() },
                    if lock { 0 } else { metadata.mtime() },
                    if lock { 0 } else { metadata.mtime_nsec() },
                ),
            );
        }
        let mut digest = Sha256::new();
        let mut sessions = Vec::new();
        for (name, signature) in files {
            use std::os::unix::ffi::OsStrExt;
            digest.update(name.as_bytes().len().to_le_bytes());
            digest.update(name.as_bytes());
            digest.update(serde_json::to_vec(&signature).map_err(|_| "discovery_unavailable")?);
            let Some(id) = name.to_str().and_then(|name| name.strip_suffix(".jsonl")) else {
                continue;
            };
            if id.len() > 64 || super::validate_session_id(id.to_owned()).is_err() {
                return Err("discovery_unavailable");
            }
            if sessions.len() == 256 {
                return Err("discovery_limit");
            }
            sessions.push(self.open(id).map_err(|_| "discovery_unavailable")?);
        }
        Ok((sessions, digest.finalize().into()))
    }
}