a3s 0.6.0

a3s — A3S coding agent CLI; `a3s code` launches the interactive TUI
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

//! Git helpers and the `/git` panel data model.

/// Current git branch of `dir` (cheap: parse `.git/HEAD`), if any.
pub(crate) fn git_branch(dir: &str) -> Option<String> {
    let head = std::fs::read_to_string(format!("{dir}/.git/HEAD")).ok()?;
    head.strip_prefix("ref: refs/heads/")
        .map(|b| b.trim().to_string())
}

/// A changed file in the `/git` panel: porcelain X (staged) + Y (unstaged).
#[derive(Clone)]
pub(crate) struct GitFile {
    pub(crate) x: char,
    pub(crate) y: char,
    pub(crate) path: String,
}

impl GitFile {
    pub(crate) fn staged(&self) -> bool {
        self.x != ' ' && self.x != '?'
    }
    pub(crate) fn untracked(&self) -> bool {
        self.x == '?'
    }
}

#[derive(Clone, Copy, PartialEq)]
pub(crate) enum GitView {
    Status,
    Log,
}

/// State of the `/git` full-screen panel (a small gitui-style view).
pub(crate) struct Git {
    pub(crate) files: Vec<GitFile>,
    pub(crate) sel: usize,
    /// Right-pane content: the selected file's diff, or the selected commit's
    /// details in the Log view.
    pub(crate) diff: Vec<String>,
    pub(crate) diff_scroll: usize,
    pub(crate) log: Vec<String>,
    pub(crate) log_sel: usize,
    pub(crate) view: GitView,
    /// `Some` while the user is typing a commit message.
    pub(crate) commit_input: Option<String>,
    pub(crate) note: String,
}

/// Run a git subcommand in `repo`, returning stdout (+ stderr on failure).
pub(crate) async fn run_git(repo: String, args: Vec<String>) -> String {
    match tokio::process::Command::new("git")
        .current_dir(&repo)
        .args(&args)
        .output()
        .await
    {
        Ok(o) => {
            let mut s = String::from_utf8_lossy(&o.stdout).into_owned();
            if !o.status.success() {
                s.push_str(&String::from_utf8_lossy(&o.stderr));
            }
            s
        }
        Err(e) => format!("git error: {e}"),
    }
}

/// Working-tree status (porcelain) + recent log for the `/git` panel.
pub(crate) async fn git_status_log(repo: String) -> (Vec<GitFile>, Vec<String>) {
    let status = run_git(
        repo.clone(),
        vec![
            "status".into(),
            "--porcelain=v1".into(),
            "--untracked-files=all".into(),
        ],
    )
    .await;
    let files = status
        .lines()
        .filter_map(|l| {
            let b = l.as_bytes();
            if b.len() < 4 {
                return None;
            }
            Some(GitFile {
                x: b[0] as char,
                y: b[1] as char,
                path: l[3..].to_string(),
            })
        })
        .collect();
    let log = run_git(
        repo,
        vec![
            "log".into(),
            "--oneline".into(),
            "-n".into(),
            "30".into(),
            "--no-color".into(),
        ],
    )
    .await
    .lines()
    .map(String::from)
    .collect();
    (files, log)
}

/// Diff for one file (whole change vs HEAD; untracked shown as all-added).
pub(crate) async fn git_diff_file(repo: String, file: GitFile) -> Vec<String> {
    let args = if file.untracked() {
        vec![
            "diff".into(),
            "--no-color".into(),
            "--no-index".into(),
            "--".into(),
            "/dev/null".into(),
            file.path.clone(),
        ]
    } else {
        vec![
            "diff".into(),
            "--no-color".into(),
            "HEAD".into(),
            "--".into(),
            file.path.clone(),
        ]
    };
    run_git(repo, args)
        .await
        .lines()
        .map(String::from)
        .collect()
}