turnlog 0.1.0

Lightweight local provenance recorder for agent sessions and turns
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

use crate::model::VcsInfo;
use std::path::{Path, PathBuf};
use std::process::Command;

fn run(cwd: &Path, cmd: &str, args: &[&str]) -> Option<String> {
    let out = Command::new(cmd)
        .args(args)
        .current_dir(cwd)
        .output()
        .ok()?;
    if !out.status.success() {
        return None;
    }
    Some(String::from_utf8_lossy(&out.stdout).trim().to_string())
}

pub fn repo_root(cwd: &Path) -> PathBuf {
    if let Some(root) = run(cwd, "jj", &["root"]).filter(|s| !s.is_empty()) {
        return PathBuf::from(root);
    }
    if let Some(root) = run(cwd, "git", &["rev-parse", "--show-toplevel"]).filter(|s| !s.is_empty())
    {
        return PathBuf::from(root);
    }
    cwd.to_path_buf()
}

pub fn detect(cwd: &Path) -> VcsInfo {
    if run(cwd, "jj", &["root"]).is_some() {
        return detect_jj(cwd);
    }
    if run(cwd, "git", &["rev-parse", "--show-toplevel"]).is_some() {
        return detect_git(cwd);
    }
    VcsInfo::None
}

pub fn diff(cwd: &Path) -> Option<String> {
    if run(cwd, "jj", &["root"]).is_some() {
        return run(cwd, "jj", &["diff", "--git"]);
    }
    if run(cwd, "git", &["rev-parse", "--show-toplevel"]).is_some() {
        return run(cwd, "git", &["diff"]);
    }
    None
}

fn detect_jj(cwd: &Path) -> VcsInfo {
    let jj_change = run(
        cwd,
        "jj",
        &["log", "-r", "@", "--no-graph", "-T", "change_id.short()"],
    );
    let jj_commit = run(
        cwd,
        "jj",
        &["log", "-r", "@", "--no-graph", "-T", "commit_id.short()"],
    );
    let jj_operation = run(
        cwd,
        "jj",
        &[
            "op",
            "log",
            "--limit",
            "1",
            "--no-graph",
            "-T",
            "id.short()",
        ],
    );
    let git_head = run(cwd, "git", &["rev-parse", "HEAD"]);
    let git_branch = run(cwd, "git", &["branch", "--show-current"]).filter(|s| !s.is_empty());
    let changed_files = jj_changed_files(cwd);
    let dirty = !changed_files.is_empty();
    VcsInfo::Jj {
        jj_change,
        jj_commit,
        jj_operation,
        git_head,
        git_branch,
        dirty,
        changed_files,
    }
}

fn detect_git(cwd: &Path) -> VcsInfo {
    let git_head = run(cwd, "git", &["rev-parse", "HEAD"]);
    let git_branch = run(cwd, "git", &["branch", "--show-current"]).filter(|s| !s.is_empty());
    let changed_files = git_changed_files(cwd);
    let dirty = !changed_files.is_empty();
    VcsInfo::Git {
        git_head,
        git_branch,
        dirty,
        changed_files,
    }
}

fn jj_changed_files(cwd: &Path) -> Vec<String> {
    let Some(raw) = run(cwd, "jj", &["status", "--no-pager"]) else {
        return vec![];
    };
    raw.lines()
        .filter(|line| {
            matches!(
                line.as_bytes().first(),
                Some(b'A' | b'M' | b'D' | b'R' | b'C')
            )
        })
        .filter_map(|line| line.get(2..).map(str::trim))
        .filter(|s| !s.is_empty())
        .map(ToOwned::to_owned)
        .collect()
}

fn git_changed_files(cwd: &Path) -> Vec<String> {
    let Some(raw) = run(cwd, "git", &["status", "--porcelain"]) else {
        return vec![];
    };
    raw.lines()
        .filter_map(|line| line.get(2..).map(str::trim))
        .filter(|s| !s.is_empty())
        .map(|s| s.split(" -> ").last().unwrap_or(s).to_string())
        .collect()
}