opensession_git_native/

shadow.rs

use std::path::Path;

use chrono::{DateTime, Utc};
use gix::object::tree::EntryKind;
use gix::{ObjectId, Repository};
use serde::{Deserialize, Serialize};
use tracing::{debug, info};

use crate::error::{GitStorageError, Result};
use crate::ops::{self, gix_err};
use crate::store::NativeGitStorage;

/// Ref prefix for shadow branches — outside refs/heads/ so they're invisible
/// to `git branch` and not included in default pushes.
pub const SHADOW_REF_PREFIX: &str = "refs/opensession/shadows/";

/// Metadata stored in `.opensession/meta.json` inside each shadow tree.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ShadowMeta {
    pub session_id: String,
    pub created_at: DateTime<Utc>,
    pub checkpoint_count: usize,
    pub tracked_files: Vec<String>,
    pub project_root: String,
}

/// A file snapshot to store in a checkpoint.
#[derive(Debug)]
pub struct FileSnapshot {
    pub rel_path: String,
    pub content: Vec<u8>,
}

/// A file removal to apply in a checkpoint.
pub struct FileRemoval {
    pub rel_path: String,
}

/// Information about a single checkpoint.
#[derive(Debug, Clone)]
pub struct CheckpointInfo {
    pub number: usize,
    pub commit_id: gix::ObjectId,
    pub file_count: usize,
    pub timestamp: DateTime<Utc>,
    pub message: String,
}

pub struct ShadowStorage;

// ── Helpers ─────────────────────────────────────────────────────────────

fn shadow_ref_name(session_id: &str) -> String {
    format!("{SHADOW_REF_PREFIX}{session_id}")
}

/// Build a new tree by upserting files, removing files, and always updating meta.
fn build_tree(
    repo: &Repository,
    base_tree_id: ObjectId,
    files: &[FileSnapshot],
    removals: &[FileRemoval],
    meta: &ShadowMeta,
) -> Result<ObjectId> {
    let mut editor = repo.edit_tree(base_tree_id).map_err(gix_err)?;

    // Upsert file snapshots
    for file in files {
        let blob_id = repo.write_blob(&file.content).map_err(gix_err)?.detach();
        editor
            .upsert(&file.rel_path, EntryKind::Blob, blob_id)
            .map_err(gix_err)?;
    }

    // Remove deleted files
    for removal in removals {
        editor.remove(&removal.rel_path).map_err(gix_err)?;
    }

    // Always upsert meta
    let meta_bytes = serde_json::to_vec_pretty(meta)?;
    let meta_blob = repo.write_blob(&meta_bytes).map_err(gix_err)?.detach();
    editor
        .upsert(".opensession/meta.json", EntryKind::Blob, meta_blob)
        .map_err(gix_err)?;

    let tree_id = editor.write().map_err(gix_err)?.detach();
    Ok(tree_id)
}

/// Generic tree walker that visits every non-meta blob in a tree.
///
/// The `visitor` receives `(relative_path, blob_data)` for each file.
fn walk_tree<F>(
    repo: &Repository,
    tree: &gix::Tree<'_>,
    prefix: &str,
    visitor: &mut F,
) -> Result<()>
where
    F: FnMut(&str, &[u8]) -> Result<()>,
{
    for entry in tree.iter() {
        let entry = entry.map_err(gix_err)?;
        let name = entry.filename().to_string();

        // Skip .opensession/ metadata directory at root level
        if prefix.is_empty() && name == ".opensession" {
            continue;
        }

        let path = if prefix.is_empty() {
            name.clone()
        } else {
            format!("{prefix}/{name}")
        };

        if entry.mode().is_tree() {
            let subtree = repo
                .find_object(entry.oid())
                .map_err(gix_err)?
                .try_into_tree()
                .map_err(gix_err)?;
            walk_tree(repo, &subtree, &path, visitor)?;
        } else {
            let blob = repo.find_object(entry.oid()).map_err(gix_err)?;
            visitor(&path, &blob.data)?;
        }
    }
    Ok(())
}

/// Count non-meta files in a tree.
fn count_tree_files(repo: &Repository, tree_id: ObjectId) -> Result<usize> {
    let tree = repo.find_tree(tree_id).map_err(gix_err)?;
    let mut count = 0usize;
    walk_tree(repo, &tree, "", &mut |_, _| {
        count += 1;
        Ok(())
    })?;
    Ok(count)
}

/// Read all non-meta file entries from a tree, returning FileSnapshots.
fn read_tree_files(repo: &Repository, tree_id: ObjectId) -> Result<Vec<FileSnapshot>> {
    let tree = repo.find_tree(tree_id).map_err(gix_err)?;
    let mut files = Vec::new();
    walk_tree(repo, &tree, "", &mut |path, data| {
        files.push(FileSnapshot {
            rel_path: path.to_string(),
            content: data.to_vec(),
        });
        Ok(())
    })?;
    Ok(files)
}

/// Walk a commit chain from tip back, collecting commits in chronological order.
fn walk_commits(repo: &Repository, tip_id: ObjectId) -> Result<Vec<(ObjectId, gix::objs::Commit)>> {
    let mut result = Vec::new();
    let mut current = tip_id;
    loop {
        let obj = repo.find_object(current).map_err(gix_err)?;
        let commit = obj.try_into_commit().map_err(gix_err)?;
        let decoded: gix::objs::Commit = commit
            .decode()
            .map_err(gix_err)?
            .to_owned()
            .map_err(gix_err)?;
        let parent = {
            let c: &gix::objs::Commit = &decoded;
            c.parents.first().copied()
        };
        result.push((current, decoded));
        match parent {
            Some(p) => current = p,
            None => break,
        }
    }
    result.reverse();
    Ok(result)
}

// ── ShadowStorage implementation ────────────────────────────────────────

impl ShadowStorage {
    /// Create or add a checkpoint on a shadow branch.
    ///
    /// If the shadow ref doesn't exist yet, creates the initial checkpoint
    /// (checkpoint 0) with an empty-tree base and no parent commit.
    /// Otherwise appends an incremental checkpoint on top of the existing tip.
    ///
    /// Returns the checkpoint number.
    pub fn checkpoint(
        repo_path: &Path,
        session_id: &str,
        files: &[FileSnapshot],
        removals: &[FileRemoval],
        meta: &ShadowMeta,
    ) -> Result<usize> {
        let repo = ops::open_repo(repo_path)?;
        let ref_name = shadow_ref_name(session_id);

        let tip = ops::find_ref_tip(&repo, &ref_name)?;

        let (base_tree_id, parent) = match tip {
            Some(id) => {
                let tree = ops::commit_tree_id(&repo, id.detach())?;
                (tree, Some(id.detach()))
            }
            None => (ObjectId::empty_tree(repo.object_hash()), None),
        };

        let tree_id = build_tree(&repo, base_tree_id, files, removals, meta)?;

        let checkpoint_num = if parent.is_some() {
            meta.checkpoint_count - 1 // meta already incremented
        } else {
            0
        };
        let changed = files.len() + removals.len();
        let message = format!("checkpoint {checkpoint_num}: {changed} files");

        let commit_id = ops::create_commit(&repo, &ref_name, tree_id, parent, &message)?;

        if parent.is_some() {
            debug!(
                session_id,
                checkpoint = checkpoint_num,
                commit = %commit_id,
                "Shadow checkpoint"
            );
        } else {
            info!(
                session_id,
                commit = %commit_id,
                "Created shadow branch with checkpoint 0"
            );
        }

        Ok(checkpoint_num)
    }

    /// Read file snapshots from a checkpoint. `None` = latest.
    pub fn read_checkpoint(
        repo_path: &Path,
        session_id: &str,
        checkpoint: Option<usize>,
    ) -> Result<Vec<FileSnapshot>> {
        let repo = ops::open_repo(repo_path)?;
        let ref_name = shadow_ref_name(session_id);

        let tip = ops::find_ref_tip(&repo, &ref_name)?
            .ok_or_else(|| GitStorageError::ShadowNotFound(session_id.to_string()))?;

        let target_commit_id = match checkpoint {
            None => tip.detach(),
            Some(n) => {
                let commits = walk_commits(&repo, tip.detach())?;
                if n >= commits.len() {
                    return Err(GitStorageError::Other(format!(
                        "checkpoint {n} not found (max: {})",
                        commits.len() - 1
                    )));
                }
                commits[n].0
            }
        };

        let tree_id = ops::commit_tree_id(&repo, target_commit_id)?;
        read_tree_files(&repo, tree_id)
    }

    /// List all checkpoints for a session.
    pub fn list_checkpoints(repo_path: &Path, session_id: &str) -> Result<Vec<CheckpointInfo>> {
        let repo = ops::open_repo(repo_path)?;
        let ref_name = shadow_ref_name(session_id);

        let tip = ops::find_ref_tip(&repo, &ref_name)?
            .ok_or_else(|| GitStorageError::ShadowNotFound(session_id.to_string()))?;

        let commits = walk_commits(&repo, tip.detach())?;
        let mut infos = Vec::with_capacity(commits.len());

        for (i, (oid, commit)) in commits.iter().enumerate() {
            let tree_id = commit.tree;
            let file_count = count_tree_files(&repo, tree_id)?;
            let timestamp =
                DateTime::from_timestamp(commit.committer.time.seconds, 0).unwrap_or_default();

            infos.push(CheckpointInfo {
                number: i,
                commit_id: *oid,
                file_count,
                timestamp,
                message: commit.message.to_string(),
            });
        }

        Ok(infos)
    }

    /// Read the shadow meta from the latest checkpoint.
    pub fn read_meta(repo_path: &Path, session_id: &str) -> Result<Option<ShadowMeta>> {
        let repo = ops::open_repo(repo_path)?;
        let ref_name = shadow_ref_name(session_id);

        let tip = match ops::find_ref_tip(&repo, &ref_name)? {
            Some(t) => t,
            None => return Ok(None),
        };

        let tree_id = ops::commit_tree_id(&repo, tip.detach())?;
        let tree = repo.find_tree(tree_id).map_err(gix_err)?;

        match tree
            .lookup_entry_by_path(".opensession/meta.json")
            .map_err(gix_err)?
        {
            Some(entry) => {
                let blob = entry.object().map_err(gix_err)?;
                let meta: ShadowMeta = serde_json::from_slice(&blob.data)?;
                Ok(Some(meta))
            }
            None => Ok(None),
        }
    }

    /// Condense: archive the final HAIL to the sessions branch, then delete the shadow.
    pub fn condense(
        repo_path: &Path,
        session_id: &str,
        final_hail: &[u8],
        final_meta: &[u8],
    ) -> Result<String> {
        let storage = NativeGitStorage;
        let rel_path =
            crate::GitStorage::store(&storage, repo_path, session_id, final_hail, final_meta)?;

        Self::drop(repo_path, session_id)?;

        info!(session_id, "Condensed shadow → {rel_path}");
        Ok(rel_path)
    }

    /// Delete the shadow ref without archiving.
    pub fn drop(repo_path: &Path, session_id: &str) -> Result<bool> {
        let repo = ops::open_repo(repo_path)?;
        let ref_name = shadow_ref_name(session_id);

        let tip = match ops::find_ref_tip(&repo, &ref_name)? {
            Some(t) => t,
            None => return Ok(false),
        };

        ops::delete_ref(&repo, &ref_name, tip.detach())?;

        info!(session_id, "Dropped shadow branch");
        Ok(true)
    }

    /// List all active shadow sessions.
    pub fn list(repo_path: &Path) -> Result<Vec<ShadowMeta>> {
        let repo = ops::open_repo(repo_path)?;
        let refs = repo.references().map_err(gix_err)?;
        let prefix_iter = refs.prefixed(SHADOW_REF_PREFIX).map_err(gix_err)?;

        let mut metas = Vec::new();

        for reference in prefix_iter {
            let reference = reference.map_err(GitStorageError::Gix)?;
            let ref_name = reference.name().as_bstr().to_string();
            let session_id = ref_name
                .strip_prefix(SHADOW_REF_PREFIX)
                .unwrap_or(&ref_name);

            match Self::read_meta(repo_path, session_id)? {
                Some(meta) => metas.push(meta),
                None => {
                    debug!(session_id, "Shadow ref exists but no meta found");
                }
            }
        }

        Ok(metas)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::test_utils::init_test_repo;

    fn make_meta(session_id: &str, checkpoint_count: usize, tracked: &[&str]) -> ShadowMeta {
        ShadowMeta {
            session_id: session_id.to_string(),
            created_at: Utc::now(),
            checkpoint_count,
            tracked_files: tracked.iter().map(|s| s.to_string()).collect(),
            project_root: "/tmp/test".to_string(),
        }
    }

    fn make_files(paths: &[(&str, &[u8])]) -> Vec<FileSnapshot> {
        paths
            .iter()
            .map(|(p, c)| FileSnapshot {
                rel_path: p.to_string(),
                content: c.to_vec(),
            })
            .collect()
    }

    #[test]
    fn test_create_and_checkpoint() {
        let tmp = tempfile::tempdir().unwrap();
        init_test_repo(tmp.path());

        let files = make_files(&[
            ("src/main.rs", b"fn main() {}"),
            ("src/lib.rs", b"pub mod foo;"),
        ]);
        let meta = make_meta("sess-001", 1, &["src/main.rs", "src/lib.rs"]);

        ShadowStorage::checkpoint(tmp.path(), "sess-001", &files, &[], &meta).unwrap();

        // Verify ref exists
        let repo = gix::open(tmp.path()).unwrap();
        let tip = ops::find_ref_tip(&repo, &shadow_ref_name("sess-001")).unwrap();
        assert!(tip.is_some());

        // Verify meta
        let read_meta = ShadowStorage::read_meta(tmp.path(), "sess-001")
            .unwrap()
            .unwrap();
        assert_eq!(read_meta.session_id, "sess-001");
        assert_eq!(read_meta.checkpoint_count, 1);
        assert_eq!(read_meta.tracked_files.len(), 2);
    }

    #[test]
    fn test_incremental_checkpoint() {
        let tmp = tempfile::tempdir().unwrap();
        init_test_repo(tmp.path());

        // Checkpoint 0
        let files0 = make_files(&[("src/main.rs", b"v1")]);
        let meta0 = make_meta("sess-002", 1, &["src/main.rs"]);
        ShadowStorage::checkpoint(tmp.path(), "sess-002", &files0, &[], &meta0).unwrap();

        // Checkpoint 1
        let files1 = make_files(&[("src/lib.rs", b"v1")]);
        let meta1 = make_meta("sess-002", 2, &["src/main.rs", "src/lib.rs"]);
        let cp1 = ShadowStorage::checkpoint(tmp.path(), "sess-002", &files1, &[], &meta1).unwrap();
        assert_eq!(cp1, 1);

        // Checkpoint 2
        let files2 = make_files(&[("tests/test.rs", b"#[test]")]);
        let meta2 = make_meta(
            "sess-002",
            3,
            &["src/main.rs", "src/lib.rs", "tests/test.rs"],
        );
        let cp2 = ShadowStorage::checkpoint(tmp.path(), "sess-002", &files2, &[], &meta2).unwrap();
        assert_eq!(cp2, 2);

        // 3 checkpoints total
        let checkpoints = ShadowStorage::list_checkpoints(tmp.path(), "sess-002").unwrap();
        assert_eq!(checkpoints.len(), 3);
    }

    #[test]
    fn test_read_checkpoint_latest() {
        let tmp = tempfile::tempdir().unwrap();
        init_test_repo(tmp.path());

        let files = make_files(&[("src/main.rs", b"fn main() { println!(\"hello\"); }")]);
        let meta = make_meta("sess-003", 1, &["src/main.rs"]);
        ShadowStorage::checkpoint(tmp.path(), "sess-003", &files, &[], &meta).unwrap();

        // Update
        let files2 = make_files(&[("src/main.rs", b"fn main() { println!(\"updated\"); }")]);
        let meta2 = make_meta("sess-003", 2, &["src/main.rs"]);
        ShadowStorage::checkpoint(tmp.path(), "sess-003", &files2, &[], &meta2).unwrap();

        // Read latest
        let snapshots = ShadowStorage::read_checkpoint(tmp.path(), "sess-003", None).unwrap();
        assert_eq!(snapshots.len(), 1);
        assert_eq!(snapshots[0].rel_path, "src/main.rs");
        assert_eq!(
            snapshots[0].content,
            b"fn main() { println!(\"updated\"); }"
        );
    }

    #[test]
    fn test_read_checkpoint_specific() {
        let tmp = tempfile::tempdir().unwrap();
        init_test_repo(tmp.path());

        // cp 0
        let files0 = make_files(&[("src/main.rs", b"version-0")]);
        let meta0 = make_meta("sess-004", 1, &["src/main.rs"]);
        ShadowStorage::checkpoint(tmp.path(), "sess-004", &files0, &[], &meta0).unwrap();

        // cp 1 — update main.rs
        let files1 = make_files(&[("src/main.rs", b"version-1")]);
        let meta1 = make_meta("sess-004", 2, &["src/main.rs"]);
        ShadowStorage::checkpoint(tmp.path(), "sess-004", &files1, &[], &meta1).unwrap();

        // Read checkpoint 0 (before update)
        let snapshots = ShadowStorage::read_checkpoint(tmp.path(), "sess-004", Some(0)).unwrap();
        let main = snapshots
            .iter()
            .find(|f| f.rel_path == "src/main.rs")
            .unwrap();
        assert_eq!(main.content, b"version-0");

        // Read checkpoint 1
        let snapshots = ShadowStorage::read_checkpoint(tmp.path(), "sess-004", Some(1)).unwrap();
        let main = snapshots
            .iter()
            .find(|f| f.rel_path == "src/main.rs")
            .unwrap();
        assert_eq!(main.content, b"version-1");
    }

    #[test]
    fn test_file_deletion() {
        let tmp = tempfile::tempdir().unwrap();
        init_test_repo(tmp.path());

        // cp 0: two files
        let files = make_files(&[("src/main.rs", b"main"), ("src/old.rs", b"old")]);
        let meta = make_meta("sess-005", 1, &["src/main.rs", "src/old.rs"]);
        ShadowStorage::checkpoint(tmp.path(), "sess-005", &files, &[], &meta).unwrap();

        // cp 1: delete old.rs
        let removals = vec![FileRemoval {
            rel_path: "src/old.rs".to_string(),
        }];
        let meta1 = make_meta("sess-005", 2, &["src/main.rs"]);
        ShadowStorage::checkpoint(tmp.path(), "sess-005", &[], &removals, &meta1).unwrap();

        // old.rs should be gone
        let snapshots = ShadowStorage::read_checkpoint(tmp.path(), "sess-005", None).unwrap();
        assert_eq!(snapshots.len(), 1);
        assert_eq!(snapshots[0].rel_path, "src/main.rs");
    }

    #[test]
    fn test_condense() {
        let tmp = tempfile::tempdir().unwrap();
        init_test_repo(tmp.path());

        // Create shadow with 3 checkpoints
        let files0 = make_files(&[("a.rs", b"v0")]);
        let meta0 = make_meta("sess-006", 1, &["a.rs"]);
        ShadowStorage::checkpoint(tmp.path(), "sess-006", &files0, &[], &meta0).unwrap();

        let files1 = make_files(&[("a.rs", b"v1")]);
        let meta1 = make_meta("sess-006", 2, &["a.rs"]);
        ShadowStorage::checkpoint(tmp.path(), "sess-006", &files1, &[], &meta1).unwrap();

        let files2 = make_files(&[("a.rs", b"v2")]);
        let meta2 = make_meta("sess-006", 3, &["a.rs"]);
        ShadowStorage::checkpoint(tmp.path(), "sess-006", &files2, &[], &meta2).unwrap();

        // Condense
        let hail = b"{\"type\":\"header\"}\n";
        let meta_json = b"{\"session_id\":\"sess-006\"}";
        let rel = ShadowStorage::condense(tmp.path(), "sess-006", hail, meta_json).unwrap();
        assert!(rel.contains("sess-006"));

        // Shadow should be gone
        let repo = gix::open(tmp.path()).unwrap();
        assert!(ops::find_ref_tip(&repo, &shadow_ref_name("sess-006"))
            .unwrap()
            .is_none());

        // Archive should exist
        let storage = NativeGitStorage;
        let loaded = crate::GitStorage::load(&storage, tmp.path(), "sess-006")
            .unwrap()
            .unwrap();
        assert_eq!(loaded, hail);
    }

    #[test]
    fn test_drop() {
        let tmp = tempfile::tempdir().unwrap();
        init_test_repo(tmp.path());

        let files = make_files(&[("a.rs", b"content")]);
        let meta = make_meta("sess-007", 1, &["a.rs"]);
        ShadowStorage::checkpoint(tmp.path(), "sess-007", &files, &[], &meta).unwrap();

        let dropped = ShadowStorage::drop(tmp.path(), "sess-007").unwrap();
        assert!(dropped);

        // Second drop returns false
        let dropped = ShadowStorage::drop(tmp.path(), "sess-007").unwrap();
        assert!(!dropped);
    }

    #[test]
    fn test_list_multiple() {
        let tmp = tempfile::tempdir().unwrap();
        init_test_repo(tmp.path());

        for id in ["alpha", "beta", "gamma"] {
            let files = make_files(&[("f.rs", id.as_bytes())]);
            let meta = make_meta(id, 1, &["f.rs"]);
            ShadowStorage::checkpoint(tmp.path(), id, &files, &[], &meta).unwrap();
        }

        let mut metas = ShadowStorage::list(tmp.path()).unwrap();
        metas.sort_by(|a, b| a.session_id.cmp(&b.session_id));
        assert_eq!(metas.len(), 3);
        assert_eq!(metas[0].session_id, "alpha");
        assert_eq!(metas[1].session_id, "beta");
        assert_eq!(metas[2].session_id, "gamma");
    }

    #[test]
    fn test_list_checkpoints() {
        let tmp = tempfile::tempdir().unwrap();
        init_test_repo(tmp.path());

        let files0 = make_files(&[("a.rs", b"v0")]);
        let meta0 = make_meta("sess-log", 1, &["a.rs"]);
        ShadowStorage::checkpoint(tmp.path(), "sess-log", &files0, &[], &meta0).unwrap();

        let files1 = make_files(&[("b.rs", b"v1")]);
        let meta1 = make_meta("sess-log", 2, &["a.rs", "b.rs"]);
        ShadowStorage::checkpoint(tmp.path(), "sess-log", &files1, &[], &meta1).unwrap();

        let checkpoints = ShadowStorage::list_checkpoints(tmp.path(), "sess-log").unwrap();
        assert_eq!(checkpoints.len(), 2);
        assert_eq!(checkpoints[0].number, 0);
        assert_eq!(checkpoints[1].number, 1);
        assert!(checkpoints[0].message.contains("checkpoint 0"));
        assert!(checkpoints[1].message.contains("checkpoint 1"));
    }

    #[test]
    fn test_shadow_ref_invisible() {
        let tmp = tempfile::tempdir().unwrap();
        init_test_repo(tmp.path());

        let files = make_files(&[("a.rs", b"data")]);
        let meta = make_meta("sess-invisible", 1, &["a.rs"]);
        ShadowStorage::checkpoint(tmp.path(), "sess-invisible", &files, &[], &meta).unwrap();

        // `git branch -a` should not show shadow refs
        let output = std::process::Command::new("git")
            .args(["branch", "-a"])
            .current_dir(tmp.path())
            .output()
            .expect("git branch failed");
        let branches = String::from_utf8_lossy(&output.stdout);
        assert!(
            !branches.contains("shadow"),
            "Shadow ref visible in git branch: {branches}"
        );
    }

    #[test]
    fn test_read_meta_recovery() {
        let tmp = tempfile::tempdir().unwrap();
        init_test_repo(tmp.path());

        // Create + 2 checkpoints
        let files0 = make_files(&[("x.rs", b"v0")]);
        let meta0 = make_meta("sess-recover", 1, &["x.rs"]);
        ShadowStorage::checkpoint(tmp.path(), "sess-recover", &files0, &[], &meta0).unwrap();

        let files1 = make_files(&[("y.rs", b"v1")]);
        let meta1 = make_meta("sess-recover", 2, &["x.rs", "y.rs"]);
        ShadowStorage::checkpoint(tmp.path(), "sess-recover", &files1, &[], &meta1).unwrap();

        // Read meta — should reflect latest state
        let meta = ShadowStorage::read_meta(tmp.path(), "sess-recover")
            .unwrap()
            .unwrap();
        assert_eq!(meta.checkpoint_count, 2);
        assert_eq!(meta.tracked_files.len(), 2);
        assert!(meta.tracked_files.contains(&"x.rs".to_string()));
        assert!(meta.tracked_files.contains(&"y.rs".to_string()));
    }

    #[test]
    fn test_checkpoint_invalid_repo() {
        let tmp = tempfile::tempdir().unwrap();
        // Don't init git — just a bare directory
        let files = make_files(&[("a.rs", b"content")]);
        let meta = make_meta("sess-bad", 1, &["a.rs"]);
        let err =
            ShadowStorage::checkpoint(tmp.path(), "sess-bad", &files, &[], &meta).unwrap_err();
        assert!(
            matches!(err, GitStorageError::NotARepo(_)),
            "expected NotARepo, got: {err}"
        );
    }

    #[test]
    fn test_read_meta_nonexistent() {
        let tmp = tempfile::tempdir().unwrap();
        init_test_repo(tmp.path());

        // No shadow created — read_meta should return None
        let meta = ShadowStorage::read_meta(tmp.path(), "no-such-session").unwrap();
        assert!(meta.is_none());
    }

    #[test]
    fn test_read_checkpoint_out_of_range() {
        let tmp = tempfile::tempdir().unwrap();
        init_test_repo(tmp.path());

        // Create one checkpoint (checkpoint 0)
        let files = make_files(&[("a.rs", b"v0")]);
        let meta = make_meta("sess-range", 1, &["a.rs"]);
        ShadowStorage::checkpoint(tmp.path(), "sess-range", &files, &[], &meta).unwrap();

        // Request checkpoint 5 which doesn't exist
        let err = ShadowStorage::read_checkpoint(tmp.path(), "sess-range", Some(5)).unwrap_err();
        assert!(
            matches!(err, GitStorageError::Other(_)),
            "expected Other error for out-of-range checkpoint, got: {err}"
        );
    }

    #[test]
    fn test_drop_nonexistent() {
        let tmp = tempfile::tempdir().unwrap();
        init_test_repo(tmp.path());

        // No shadow exists — drop returns false
        let dropped = ShadowStorage::drop(tmp.path(), "no-such-shadow").unwrap();
        assert!(!dropped);
    }

    #[test]
    fn test_checkpoint_empty_files() {
        let tmp = tempfile::tempdir().unwrap();
        init_test_repo(tmp.path());

        // Checkpoint with no files — only meta should be written
        let meta = make_meta("sess-empty", 1, &[]);
        let cp = ShadowStorage::checkpoint(tmp.path(), "sess-empty", &[], &[], &meta).unwrap();
        assert_eq!(cp, 0);

        // Read it back — should have zero user files
        let snapshots = ShadowStorage::read_checkpoint(tmp.path(), "sess-empty", None).unwrap();
        assert!(
            snapshots.is_empty(),
            "expected no user files, got: {}",
            snapshots.len()
        );

        // But meta should still be readable
        let read_meta = ShadowStorage::read_meta(tmp.path(), "sess-empty")
            .unwrap()
            .unwrap();
        assert_eq!(read_meta.session_id, "sess-empty");
    }

    #[test]
    fn test_condense_nonexistent() {
        let tmp = tempfile::tempdir().unwrap();
        init_test_repo(tmp.path());

        // No shadow exists — condense should still succeed (store works, drop returns false)
        // But the session data will be archived even though there's no shadow to remove
        let result = ShadowStorage::condense(
            tmp.path(),
            "no-shadow",
            b"{\"event\":\"test\"}\n",
            b"{\"id\":\"no-shadow\"}",
        );
        // condense calls store (succeeds) then drop (returns false, not error), so it succeeds
        assert!(result.is_ok());
    }
}