ccswarm 0.9.0

AI Agent Workflow DevOps toolchain complementing Claude Code Agent Teams
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
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

use super::super::*;
use crate::hitl::{ApprovalRecord, ApprovalStatus, ApprovalStore, Gate};

impl CliRunner {
    pub(crate) async fn handle_approve(&self, action: &ApproveAction) -> Result<()> {
        match action {
            ApproveAction::Plan { id, reject, reason } => {
                self.process_approval(Gate::Plan, id, *reject, reason.as_deref())
                    .await?;
            }
            ApproveAction::RiskyEdit { id, reject, reason } => {
                self.process_approval(Gate::RiskyEdit, id, *reject, reason.as_deref())
                    .await?;
            }
            ApproveAction::Deploy { id, reject, reason } => {
                self.process_approval(Gate::Deploy, id, *reject, reason.as_deref())
                    .await?;
            }
            ApproveAction::Merge { id, reject, reason } => {
                self.process_approval(Gate::Merge, id, *reject, reason.as_deref())
                    .await?;
            }
            ApproveAction::Commit { id, reject, reason } => {
                self.process_approval(Gate::Commit, id, *reject, reason.as_deref())
                    .await?;
            }
            ApproveAction::List { status } => {
                self.list_approvals(status.as_deref()).await?;
            }
        }

        Ok(())
    }

    async fn process_approval(
        &self,
        gate: Gate,
        id: &str,
        reject: bool,
        reason: Option<&str>,
    ) -> Result<()> {
        let store = ApprovalStore::new(&self.repo_path);
        let record = store.decide(id, gate, !reject, reason).await?;
        let status = if reject { "rejected" } else { "approved" };

        if self.json_output {
            println!(
                "{}",
                serde_json::to_string_pretty(&serde_json::json!({
                    "status": "success",
                    "message": format!("Decision recorded: {}", status),
                    "data": record,
                }))?
            );
        } else {
            let status_colored = if reject {
                status.bright_red().bold()
            } else {
                status.bright_green().bold()
            };
            println!(
                "{} [{}] {} {}",
                "OK".bright_green().bold(),
                gate.to_string().bright_cyan(),
                id.bright_yellow(),
                status_colored
            );
            if let Some(r) = reason {
                println!("  Reason: {}", r);
            }
        }

        Ok(())
    }

    async fn list_approvals(&self, status_filter: Option<&str>) -> Result<()> {
        let store = ApprovalStore::new(&self.repo_path);
        let approvals: Vec<ApprovalRecord> = store
            .list()
            .await?
            .into_iter()
            .filter(|r| {
                status_filter.is_none_or(|filter| {
                    let st = match r.status {
                        ApprovalStatus::Pending => "pending",
                        ApprovalStatus::Approved => "approved",
                        ApprovalStatus::Rejected => "rejected",
                    };
                    st == filter
                })
            })
            .collect();

        if self.json_output {
            println!(
                "{}",
                serde_json::to_string_pretty(&serde_json::json!({
                    "status": "success",
                    "data": approvals,
                }))?
            );
        } else if approvals.is_empty() {
            println!("No approval records found.");
        } else {
            println!("{}", "Approvals".bright_cyan().bold());
            println!("{}", "=========".bright_cyan());
            for record in &approvals {
                let status_colored = match record.status {
                    ApprovalStatus::Approved => "approved".bright_green(),
                    ApprovalStatus::Rejected => "rejected".bright_red(),
                    ApprovalStatus::Pending => "pending".bright_yellow(),
                };
                let ts = record
                    .decided_at
                    .as_deref()
                    .or(record.requested_at.as_deref())
                    .unwrap_or("?");
                println!(
                    "  {} [{}] {} ({})",
                    record.id.bright_yellow(),
                    record.gate.to_string().bright_cyan(),
                    status_colored,
                    ts.bright_black()
                );
            }
            println!("\nTotal: {} records", approvals.len());
        }

        Ok(())
    }
}