req-cli 0.4.0-rc.3

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

// Implements REQ-0013 (reject parent links that would create a cycle).
use anyhow::{anyhow, Result};
use chrono::Utc;
use std::path::PathBuf;

use crate::cli::LinkArgs;
use crate::model::{Link, LinkKind};
use crate::storage::{self, load_for_mutation};

pub fn run(mut args: LinkArgs, file: &Option<PathBuf>) -> Result<()> {
    let (path, mut project, _lock) = load_for_mutation(file)?;
    args.from = super::resolve_id(&project, &args.from)?;
    args.to = super::resolve_id(&project, &args.to)?;

    if args.from == args.to {
        return Err(anyhow!("cannot link a requirement to itself"));
    }
    let kind: LinkKind = args.kind.into();

    // Cycle-check every asymmetric link kind. `conflicts` is symmetric
    // (A conflicts with B == B conflicts with A) so a "cycle" is just a
    // duplicate — caught by the duplicate-link check below.
    let cycle_checked = matches!(
        kind,
        LinkKind::Parent | LinkKind::DependsOn | LinkKind::Refines | LinkKind::Verifies
    );
    if cycle_checked && !args.remove && creates_cycle(&project, &args.from, &args.to, kind) {
        return Err(anyhow!(
            "linking {} -> {} {} would create a cycle",
            args.from,
            kind.as_str(),
            args.to
        ));
    }

    let r = project
        .requirements
        .get_mut(&args.from)
        .ok_or_else(|| anyhow!("source {} does not exist", args.from))?;

    if args.remove {
        let before = r.links.len();
        r.links.retain(|l| !(l.kind == kind && l.target == args.to));
        if r.links.len() == before {
            return Err(anyhow!("no such link to remove"));
        }
        r.history.push(super::history(
            format!("removed {} link to {}", kind.as_str(), args.to),
            None,
        ));
    } else {
        if r.links
            .iter()
            .any(|l| l.kind == kind && l.target == args.to)
        {
            return Err(anyhow!("link already exists"));
        }
        r.links.push(Link {
            kind,
            target: args.to.clone(),
        });
        r.history.push(super::history(
            format!("added {} link to {}", kind.as_str(), args.to),
            None,
        ));
    }
    r.updated = Utc::now();
    project.updated = Utc::now();
    storage::save(&path, &project)?;
    if args.json {
        println!(
            "{}",
            serde_json::to_string_pretty(&serde_json::json!({
                "from": args.from, "to": args.to,
                "kind": kind.as_str(), "removed": args.remove
            }))?
        );
    } else {
        println!("OK");
    }
    Ok(())
}

/// Walk forward along same-kind links from `target` and report whether the
/// chain reaches `from` (which would close a cycle once the new link is
/// added). Generalised from the original parent-only walker so every
/// asymmetric link kind gets the same protection.
fn creates_cycle(
    project: &crate::model::Project,
    from: &str,
    target: &str,
    kind: LinkKind,
) -> bool {
    let mut current = target.to_string();
    let mut visited = Vec::new();
    loop {
        if current == from {
            return true;
        }
        if visited.contains(&current) {
            return false;
        }
        visited.push(current.clone());
        let next = project.requirements.get(&current).and_then(|r| {
            r.links
                .iter()
                .find(|l| l.kind == kind)
                .map(|l| l.target.clone())
        });
        match next {
            Some(n) => current = n,
            None => return false,
        }
    }
}