agentdiff 0.1.13

Audit and trace autonomous AI code contributions in git repositories
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use serde::{Deserialize, Serialize};
use std::path::PathBuf;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Config {
    /// Schema version for future migrations
    #[serde(default = "default_schema")]
    pub schema_version: String,

    /// Global spillover root — defaults to ~/.agentdiff/spillover
    #[serde(default)]
    pub data_dir: Option<PathBuf>,

    /// Global scripts dir — defaults to ~/.agentdiff/scripts
    #[serde(default)]
    pub scripts_dir: Option<PathBuf>,

    /// Repos this instance manages (repo-root → slug mapping)
    #[serde(default)]
    pub repos: Vec<RepoConfig>,

    /// Agents to include/exclude from stats
    #[serde(default)]
    pub agent_aliases: std::collections::HashMap<String, String>,

    /// Include .agentdiff/ledger.jsonl in the same commit via post-commit amend.
    #[serde(default = "default_auto_amend_ledger")]
    pub auto_amend_ledger: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RepoConfig {
    pub path: PathBuf,
    pub slug: String,
}

fn default_schema() -> String {
    "1.0".to_string()
}

fn default_auto_amend_ledger() -> bool {
    true
}

impl Default for Config {
    fn default() -> Self {
        Self {
            schema_version: "1.0".to_string(),
            data_dir: None,
            scripts_dir: None,
            repos: Vec::new(),
            agent_aliases: std::collections::HashMap::new(),
            auto_amend_ledger: true,
        }
    }
}

impl Config {
    /// ~/.agentdiff/config.toml
    pub fn config_path() -> PathBuf {
        dirs::home_dir()
            .expect("home dir must exist")
            .join(".agentdiff")
            .join("config.toml")
    }

    /// Legacy config path from earlier agentblame versions.
    pub fn legacy_config_path() -> PathBuf {
        dirs::home_dir()
            .expect("home dir must exist")
            .join(".agentblame")
            .join("config.toml")
    }

    /// Global spillover dir for events captured outside a git repo.
    pub fn spillover_root(&self) -> PathBuf {
        self.data_dir.clone().unwrap_or_else(|| {
            dirs::home_dir()
                .unwrap()
                .join(".agentdiff")
                .join("spillover")
        })
    }

    pub fn scripts_root(&self) -> PathBuf {
        self.scripts_dir
            .clone()
            .unwrap_or_else(|| dirs::home_dir().unwrap().join(".agentdiff").join("scripts"))
    }

    pub fn auto_amend_ledger_enabled(&self) -> bool {
        self.auto_amend_ledger
    }

    /// Derive slug from repo root path: /home/prakh/dev/rust → -home-prakh-dev-rust
    pub fn slug_for(repo_root: &std::path::Path) -> String {
        repo_root.to_string_lossy().replace('/', "-")
    }

    /// Session directory for the current repo.
    pub fn repo_session_dir(repo_root: &std::path::Path) -> PathBuf {
        repo_root.join(".git").join("agentdiff")
    }

    pub fn repo_session_log(repo_root: &std::path::Path) -> PathBuf {
        Self::repo_session_dir(repo_root).join("session.jsonl")
    }

    pub fn repo_lockfile(repo_root: &std::path::Path) -> PathBuf {
        Self::repo_session_dir(repo_root).join("hook.lock")
    }

    pub fn repo_pending_context(repo_root: &std::path::Path) -> PathBuf {
        Self::repo_session_dir(repo_root).join("pending.json")
    }

    pub fn repo_pending_ledger(repo_root: &std::path::Path) -> PathBuf {
        Self::repo_session_dir(repo_root).join("pending-ledger.json")
    }

    pub fn repo_ledger_dir(repo_root: &std::path::Path) -> PathBuf {
        repo_root.join(".agentdiff")
    }

    pub fn repo_ledger_path(repo_root: &std::path::Path) -> PathBuf {
        Self::repo_ledger_dir(repo_root).join("ledger.jsonl")
    }

    pub fn load() -> anyhow::Result<Self> {
        let primary = Self::config_path();
        if primary.exists() {
            let raw = std::fs::read_to_string(&primary)?;
            return Ok(toml::from_str(&raw)?);
        }
        let legacy = Self::legacy_config_path();
        if legacy.exists() {
            let raw = std::fs::read_to_string(&legacy)?;
            return Ok(toml::from_str(&raw)?);
        }
        Ok(Config::default())
    }

    pub fn save(&self) -> anyhow::Result<()> {
        let path = Self::config_path();
        if let Some(parent) = path.parent() {
            std::fs::create_dir_all(parent)?;
        }
        let toml_str = toml::to_string_pretty(self)?;
        std::fs::write(&path, toml_str)?;
        Ok(())
    }
}