apm-cli 0.1.9

CLI project manager for running AI coding agents in parallel, isolated by design.
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

use anyhow::Result;
use apm_core::config::{CompletionStrategy, Config};
use std::collections::HashSet;
use std::path::Path;
use crate::ctx::CmdContext;

pub fn run(root: &Path, fix: bool, no_aggressive: bool) -> Result<()> {
    let ctx = CmdContext::load(root, no_aggressive)?;

    let merged = apm_core::git::merged_into_main(root, &ctx.config.project.default_branch).unwrap_or_default();
    let merged_set: HashSet<String> = merged.into_iter().collect();

    let issues = apm_core::verify::verify_tickets(&ctx.config, &ctx.tickets, &merged_set);

    // Report completion strategies configured on transitions.
    for state in &ctx.config.workflow.states {
        for tr in &state.transitions {
            let label = match &tr.completion {
                CompletionStrategy::Pr => "pr",
                CompletionStrategy::Merge => "merge",
                CompletionStrategy::Pull => "pull",
                CompletionStrategy::PrOrEpicMerge => "pr_or_epic_merge",
                CompletionStrategy::None => continue,
            };
            println!("completion: {} → {} = {label}", state.id, tr.to);
        }
    }

    if ctx.config.logging.enabled {
        let log_path = apm_core::logger::resolve_log_path(
            &ctx.config.project.name,
            ctx.config.logging.file.as_deref(),
        );
        println!("logging: {}", log_path.display());
    }

    if issues.is_empty() {
        println!("verify: no issues found");
        return Ok(());
    }

    for issue in &issues {
        println!("{issue}");
    }

    if fix {
        let merged_refs: HashSet<&str> = merged_set.iter().map(|s| s.as_str()).collect();
        apply_fixes(root, &ctx.config, &ctx.tickets, &merged_refs)?;
    }

    std::process::exit(1);
}

fn apply_fixes(
    root: &Path,
    config: &Config,
    tickets: &[apm_core::ticket::Ticket],
    merged_set: &HashSet<&str>,
) -> Result<()> {
    for t in tickets {
        let fm = &t.frontmatter;
        let Some(branch) = &fm.branch else { continue };
        if (fm.state == "in_progress" || fm.state == "implemented")
            && merged_set.contains(branch.as_str())
        {
            let id = fm.id.clone();
            let old_state = fm.state.clone();
            match apm_core::ticket::close(root, config, &id, None, "verify --fix", false) {
                Ok(msgs) => {
                    for msg in &msgs {
                        println!("{msg}");
                    }
                    println!("  fixed {id}: {old_state} → closed");
                }
                Err(e) => eprintln!("  warning: could not fix {id}: {e:#}"),
            }
        }
    }
    Ok(())
}