bmo 0.6.0

Local-first SQLite-backed CLI issue tracker for AI agents
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

use clap::Args;

use crate::cli::parse_id;
use crate::config::find_bmo_dir;
use crate::db::{ClaimIssueInput, Repository, open_db};
use crate::errors::{BmoError, ErrorCode};

#[derive(Args)]
pub struct ClaimArgs {
    /// Issue ID (e.g. 7 or BMO-7)
    pub id: String,
    /// Assignee name to record on the issue
    #[arg(short, long)]
    pub assignee: Option<String>,
}

pub fn run(args: &ClaimArgs, json: bool) -> anyhow::Result<()> {
    let bmo_dir = find_bmo_dir()?;
    let repo = open_db(&bmo_dir.join("issues.db"))?;

    let issue_id = parse_id(&args.id)?;

    match repo.claim_issue(&ClaimIssueInput {
        issue_id,
        assignee: args.assignee.clone(),
    }) {
        Ok(issue) => {
            let display = issue.display_id();
            let file_conflicts = repo.list_file_conflicts(issue_id)?;

            if json {
                let mut envelope = serde_json::json!({
                    "ok": true,
                    "data": issue,
                    "message": format!("Claimed {}.", display),
                });
                if !file_conflicts.is_empty() {
                    envelope["file_conflicts"] =
                        serde_json::to_value(&file_conflicts).unwrap_or_default();
                }
                println!("{}", serde_json::to_string_pretty(&envelope)?);
            } else {
                println!("Claimed {}.", display);
                for conflict in &file_conflicts {
                    for ci in &conflict.conflicts_with {
                        println!(
                            "Warning: file conflict on {} with BMO-{} ({})",
                            conflict.file, ci.id, ci.title
                        );
                    }
                }
            }
            Ok(())
        }
        Err(e) => {
            if let Some(BmoError::Conflict(_)) = e.downcast_ref::<BmoError>() {
                let msg = format!("BMO-{} is already in-progress", issue_id);
                if json {
                    let out = serde_json::json!({
                        "ok": false,
                        "code": ErrorCode::Conflict.as_str(),
                        "error": msg,
                    });
                    println!("{}", serde_json::to_string_pretty(&out)?);
                } else {
                    eprintln!("error: {}", msg);
                }
                std::process::exit(ErrorCode::Conflict.exit_code());
            }

            if let Some(BmoError::NotFound(_)) = e.downcast_ref::<BmoError>() {
                let msg = e.to_string();
                if json {
                    let out = serde_json::json!({
                        "ok": false,
                        "code": ErrorCode::NotFound.as_str(),
                        "error": msg,
                    });
                    println!("{}", serde_json::to_string_pretty(&out)?);
                } else {
                    eprintln!("error: {}", msg);
                }
                std::process::exit(ErrorCode::NotFound.exit_code());
            }

            Err(e)
        }
    }
}