govctl 0.9.3

Project governance CLI for RFC, ADR, and Work Item management
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181

use super::*;

#[test]
fn test_edit_plans_are_mutating() -> Result<(), Box<dyn std::error::Error>> {
    let plan = crate::RfcCommand::Edit(crate::CommonEditArgs {
        id: "RFC-0001".to_string(),
        path: "title".to_string(),
        action: EditActionArgs {
            set: Some(Some("X".to_string())),
            add: None,
            remove: None,
            tick: None,
            stdin: false,
            at: None,
            exact: false,
            regex: false,
            all: false,
        },
    })
    .to_plan()?;
    assert!(matches!(plan.scope, Scope::Target { .. }));
    assert!(matches!(plan.op, Op::Edit(EditOp::Field { .. })));
    assert_eq!(plan.lock_disposition(), LockDisposition::GovRootExclusive);

    let plan = ClauseCommand::Edit {
        id: "RFC-0001:C-TEST".to_string(),
        path: None,
        set: None,
        add: None,
        remove: None,
        tick: None,
        stdin: true,
        at: None,
        exact: false,
        regex: false,
        all: false,
        text: None,
        text_file: None,
    }
    .to_plan()?;
    assert!(matches!(plan.op, Op::Edit(EditOp::ClauseLegacy { .. })));
    assert_eq!(plan.lock_disposition(), LockDisposition::GovRootExclusive);
    Ok(())
}

#[test]
fn test_read_plans_are_lock_free() -> Result<(), Box<dyn std::error::Error>> {
    let status = global(Op::Builtin(BuiltinOp::Status));
    assert_eq!(status.lock_disposition(), LockDisposition::None);

    let plan = plan_get("RFC-0001", Some("title"))?;
    assert!(matches!(plan.scope, Scope::Target { .. }));
    assert!(matches!(plan.op, Op::Get));
    assert_eq!(plan.lock_disposition(), LockDisposition::None);
    Ok(())
}

#[test]
fn test_lock_disposition_is_lock_free_for_inspect_commands()
-> Result<(), Box<dyn std::error::Error>> {
    assert_eq!(
        global(Op::Builtin(BuiltinOp::Status)).lock_disposition(),
        LockDisposition::None
    );
    assert_eq!(
        global(Op::Builtin(BuiltinOp::LoopList {
            filter: None,
            limit: None,
            output: OutputFormat::Table,
        }))
        .lock_disposition(),
        LockDisposition::None
    );
    assert_eq!(
        global(Op::Builtin(BuiltinOp::LoopShow {
            loop_id: "LOOP-2026-04-07-001".to_string(),
        }))
        .lock_disposition(),
        LockDisposition::None
    );
    assert_eq!(
        global(Op::Builtin(BuiltinOp::LoopResume {
            loop_id: "LOOP-2026-04-07-001".to_string(),
        }))
        .lock_disposition(),
        LockDisposition::None
    );
    assert_eq!(
        global(Op::Builtin(BuiltinOp::TagList {
            output: OutputFormat::Table,
        }))
        .lock_disposition(),
        LockDisposition::None
    );
    assert_eq!(
        global(Op::Builtin(BuiltinOp::Search {
            query: vec!["cache".to_string()],
            types: vec![],
            tags: vec![],
            limit: None,
            output: OutputFormat::Table,
            reindex: false,
        }))
        .lock_disposition(),
        LockDisposition::None
    );
    assert_eq!(
        plan_get("RFC-0001", Some("title"))?.lock_disposition(),
        LockDisposition::None
    );
    assert_eq!(
        plan_show(
            cmd::edit::ArtifactType::Adr,
            "ADR-0038",
            OutputFormat::Table
        )
        .lock_disposition(),
        LockDisposition::None
    );
    Ok(())
}

#[test]
fn test_lock_disposition_requires_lock_for_mutating_commands()
-> Result<(), Box<dyn std::error::Error>> {
    assert_eq!(
        global(Op::Builtin(BuiltinOp::Init { force: false })).lock_disposition(),
        LockDisposition::GovRootExclusive
    );
    assert_eq!(
        global(Op::Builtin(BuiltinOp::LoopRun {
            loop_id: "LOOP-2026-04-07-001".to_string(),
            target_work_ids: vec![],
            max_rounds: 1,
        }))
        .lock_disposition(),
        LockDisposition::GovRootExclusive
    );
    assert_eq!(
        global(Op::Builtin(BuiltinOp::LoopReplan {
            loop_id: "LOOP-2026-04-07-001".to_string(),
        }))
        .lock_disposition(),
        LockDisposition::GovRootExclusive
    );
    assert_eq!(
        plan_edit(
            "WI-2026-04-07-004",
            "acceptance_criteria[0]",
            tick_action(OwnedMatchOptions::default(), TickStatus::Done),
            EditExtras::default(),
        )?
        .lock_disposition(),
        LockDisposition::GovRootExclusive
    );
    assert_eq!(
        plan_lifecycle(
            cmd::edit::ArtifactType::WorkItem,
            "WI-2026-04-07-004",
            LifecycleOp::MoveWork {
                file_or_id: std::path::PathBuf::from("WI-2026-04-07-004"),
                status: WorkItemStatus::Done,
            },
        )
        .lock_disposition(),
        LockDisposition::GovRootExclusive
    );
    Ok(())
}

#[test]
fn test_self_update_is_lock_free() {
    assert_eq!(
        global(Op::Builtin(BuiltinOp::SelfUpdate { check: true })).lock_disposition(),
        LockDisposition::None
    );
    assert_eq!(
        global(Op::Builtin(BuiltinOp::SelfUpdate { check: false })).lock_disposition(),
        LockDisposition::None
    );
}