req-cli 0.2.2

Managed requirements CLI for LLM agents and humans
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

// Tests for Slice C: REQ-0066 (batch) and REQ-0067 (import).
mod common;
use common::{stderr, stdout, Sandbox};
use std::fs;

// ---------- REQ-0066: req batch ----------

#[test]
fn req_0066_batch_applies_multiple_mutations_atomically() {
    let s = Sandbox::new();
    s.init("p");
    let doc = serde_json::json!({
        "reason": "First batch smoke",
        "mutations": [
            { "kind": "add",
              "title": "First batched req here",
              "statement": "The system shall accept this from a batch document.",
              "rationale": "Test the batch path.",
              "req_kind": "constraint", "priority": "could" },
            { "kind": "add",
              "title": "Second batched req here",
              "statement": "The system shall also accept this from a batch document.",
              "rationale": "Test the batch path.",
              "req_kind": "constraint", "priority": "could" },
            { "kind": "link", "from": "REQ-0002", "to": "REQ-0001", "link_kind": "parent" }
        ]
    });
    let path = s.dir.path().join("batch.json");
    fs::write(&path, serde_json::to_string_pretty(&doc).unwrap()).unwrap();
    let out = s.run(&["batch", path.to_str().unwrap()]);
    assert!(out.status.success(), "stderr: {}", stderr(&out));
    let list = stdout(&s.run(&["list", "--json"]));
    assert!(list.contains("REQ-0001"));
    assert!(list.contains("REQ-0002"));
}

#[test]
fn req_0066_batch_rolls_back_on_validation_failure() {
    let s = Sandbox::new();
    s.init("p");
    // Take a snapshot of the project file BEFORE the bad batch
    let before = fs::read(s.path()).unwrap();
    let doc = serde_json::json!({
        "mutations": [
            { "kind": "add",
              "title": "First good req here",
              "statement": "The system shall accept this perfectly fine requirement.",
              "rationale": "Good one.",
              "req_kind": "constraint", "priority": "could" },
            // This one fails (no modal verb)
            { "kind": "add",
              "title": "Second bad req here",
              "statement": "Does nothing useful at all here.",
              "rationale": "Bad — no modal verb.",
              "req_kind": "constraint", "priority": "could" }
        ]
    });
    let path = s.dir.path().join("bad.json");
    fs::write(&path, serde_json::to_string_pretty(&doc).unwrap()).unwrap();
    let out = s.run(&["batch", path.to_str().unwrap()]);
    assert!(!out.status.success());
    // File must be byte-identical to its pre-batch state
    let after = fs::read(s.path()).unwrap();
    assert_eq!(
        before, after,
        "project.req should be unchanged after rollback"
    );
}

// ---------- REQ-0067: req import ----------

#[test]
fn req_0067_import_markdown_accepts_well_formed_items() {
    let s = Sandbox::new();
    s.init("p");
    let md = r#"
## First imported requirement here

The system shall implement the first imported behaviour as described.

Rationale: This is an import smoke test.

Acceptance:
- The first behaviour is reproducible
- Coverage notices it

Tags: import, smoke

## Second imported requirement here

The system shall also implement a second behaviour from markdown import.

Rationale: Multiple items in one document.

Acceptance:
- Second behaviour is independently testable
"#;
    let path = s.dir.path().join("spec.md");
    fs::write(&path, md).unwrap();
    let out = s.run(&["import", "-f", "markdown", path.to_str().unwrap(), "--json"]);
    assert!(out.status.success(), "stderr: {}", stderr(&out));
    let body = stdout(&out);
    let v: serde_json::Value = serde_json::from_str(&body).expect("import --json shape");
    assert_eq!(v["accepted"].as_array().unwrap().len(), 2);
    assert!(v["rejected"].as_array().unwrap().is_empty());
}

#[test]
fn req_0067_import_dry_run_does_not_write() {
    let s = Sandbox::new();
    s.init("p");
    let before = fs::read(s.path()).unwrap();
    let md = r#"
## Dry-run imported requirement

The system shall be visible in the report but not written when dry-run is set.

Rationale: Test the --dry-run flag.
"#;
    let path = s.dir.path().join("dry.md");
    fs::write(&path, md).unwrap();
    let out = s.run(&[
        "import",
        "-f",
        "markdown",
        path.to_str().unwrap(),
        "--dry-run",
    ]);
    assert!(out.status.success(), "stderr: {}", stderr(&out));
    let after = fs::read(s.path()).unwrap();
    assert_eq!(before, after, "project.req unchanged on dry-run");
}

#[test]
fn req_0067_import_json_array_schema() {
    let s = Sandbox::new();
    s.init("p");
    let doc = serde_json::json!([
        {
            "title": "From JSON array form",
            "statement": "The system shall ingest items from a flat JSON array.",
            "rationale": "Convenient bulk import path.",
            "kind": "constraint",
            "priority": "could"
        }
    ]);
    let path = s.dir.path().join("items.json");
    fs::write(&path, serde_json::to_string_pretty(&doc).unwrap()).unwrap();
    let out = s.run(&["import", "-f", "json", path.to_str().unwrap(), "--json"]);
    assert!(out.status.success(), "stderr: {}", stderr(&out));
    let v: serde_json::Value = serde_json::from_str(&stdout(&out)).unwrap();
    assert_eq!(v["accepted"].as_array().unwrap().len(), 1);
}