moor 0.7.0

Build software with an AI agent inside a locked-down container
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

use crate::guide;
use crate::{audit, manifest, manifest::Manifest, paths, proc};
use anyhow::{Context, Result};

/// The project a guided command acts on, resolved once and shared by
/// `moor next` and the commands that move a spec on (`flow_cmd`).
pub struct Target {
    pub name: String,
    pub m: Manifest,
    /// `--project` for printed commands: only when they'd otherwise resolve
    /// to a different project, since naming the sticky default is redundant.
    pub flag: Option<String>,
}

impl Target {
    /// Resolves the project and checks its sandbox is up — every guided
    /// command needs to ask the sandbox where things stand.
    pub fn resolve(explicit: Option<String>) -> Result<Self> {
        let (name, _) = super::resolve_project(explicit.clone())?;
        let m = Manifest::load(&paths::manifest_path(&name)?)?;
        if super::running_projects(std::slice::from_ref(&name))?.is_empty() {
            anyhow::bail!(
                "{name} isn't running, so moor can't say where things stand.\n\n  Next:  moor up {name}"
            );
        }
        let flag =
            explicit.filter(|p| paths::read_current_project().ok().flatten().as_ref() != Some(p));
        Ok(Target { name, m, flag })
    }

    /// Where every spec stands, from the sandbox. Logged like any exec.
    pub fn report(&self) -> Result<guide::NextReport> {
        let argv: Vec<String> = ["keel", "next", "--json"].map(String::from).to_vec();
        let container = self.m.sandbox_container();
        let mut args: Vec<&str> = vec!["exec", &container];
        args.extend(argv.iter().map(String::as_str));
        let (status, out) = proc::run_capture("docker", &args)?;
        audit::log_exec(&self.name, &self.m, "next", &argv, status.code())?;
        proc::require_success(&format!("asking {container} where things stand"), status)?;
        serde_json::from_str(out.trim()).context("parsing the sandbox's pipeline status")
    }

    /// Runs `argv` in the sandbox, capturing its combined output, logged
    /// under `kind` like any exec. Returns whether it succeeded.
    pub fn exec(&self, kind: &str, argv: &[&str]) -> Result<(bool, String)> {
        let container = self.m.sandbox_container();
        let mut args = vec!["exec", container.as_str()];
        args.extend_from_slice(argv);
        let (status, out) = proc::run_capture_combined("docker", &args)?;
        let logged: Vec<String> = argv.iter().map(|a| a.to_string()).collect();
        audit::log_exec(&self.name, &self.m, kind, &logged, status.code())?;
        Ok((status.success(), out))
    }

    /// Specs whose folder has uncommitted changes: approved work that
    /// hasn't been shipped yet, when the spec is also complete.
    pub fn unshipped(&self, report: &guide::NextReport) -> Result<Vec<String>> {
        let (ok, out) = self.exec(
            "next",
            &[
                "git",
                "status",
                "--porcelain",
                "--untracked-files=all",
                "--",
                ".keel/specs",
            ],
        )?;
        if !ok {
            return Ok(vec![]);
        }
        Ok(report
            .specs
            .iter()
            .filter(|s| s.complete)
            .filter(|s| {
                let dir = format!(".keel/specs/{}/", s.slug);
                out.lines()
                    .any(|l| l.get(3..).is_some_and(|p| p.starts_with(&dir)))
            })
            .map(|s| s.slug.clone())
            .collect())
    }

    /// The spec guidance is about — see `guide::pick_active`.
    pub fn active<'a>(&self, report: &'a guide::NextReport) -> Option<guide::Active<'a>> {
        let chain: Vec<String> = paths::chain_log_path(&self.name)
            .and_then(|p| Ok(std::fs::read_to_string(p)?))
            .map(|s| s.lines().map(String::from).collect())
            .unwrap_or_default();
        guide::pick_active(report, read_pin(&self.name).as_deref(), &chain)
    }

    /// The guidance block, ending on its "Next:" line (plus a tip when
    /// the printed commands carry `--project`).
    pub fn print_guidance(&self, report: &guide::NextReport) {
        let unshipped = self.unshipped(report).unwrap_or_default();
        let active = self.active(report);
        // An explicit pin wins: if the operator pinned an in-progress spec,
        // guide that one even when other approved work is waiting to ship —
        // the pin is a clear "I'm working on this" signal. Without a pin,
        // approved-but-unshipped work comes first, because starting the next
        // spec on top of it is how two specs' changes end up tangled.
        let pinned_active = active
            .as_ref()
            .filter(|a| a.why == guide::Why::Pinned)
            .is_some();
        let mut lines = match unshipped.first() {
            Some(slug) if !pinned_active => {
                guide::render_ship(&self.name, self.flag.as_deref(), slug, unshipped.len())
            }
            _ => guide::render(&self.name, self.flag.as_deref(), report, active.as_ref()),
        };
        // When the pin took precedence but approved work is still waiting,
        // say so, so it isn't silently forgotten.
        if pinned_active {
            if let Some(slug) = unshipped.first() {
                let more = if unshipped.len() > 1 {
                    format!(" (and {} other spec(s))", unshipped.len() - 1)
                } else {
                    String::new()
                };
                lines.push(String::new());
                lines.push(format!(
                    "  Also: '{slug}'{more} is approved and waiting to ship — `moor ship` when ready."
                ));
            }
        }
        if self.flag.is_some() {
            lines.push(String::new());
            lines.push(format!(
                "  Tip: `moor use {}` drops --project from these commands.",
                self.name
            ));
        }
        for line in lines {
            println!("{line}");
        }
    }
}

/// The pinned spec, if one is set and still a well-formed slug. A
/// hand-edited file that isn't one is treated as no pin, not an error.
pub(crate) fn read_pin(name: &str) -> Option<String> {
    let raw = std::fs::read_to_string(paths::active_spec_path(name).ok()?).ok()?;
    let slug = raw.trim();
    manifest::validate_name(slug).ok()?;
    Some(slug.to_string())
}

/// The closing line for a command that isn't itself guided: how to ask
/// where `name` stands, with `--project` only if it isn't the default.
pub fn next_hint(name: &str) -> String {
    let sticky = paths::read_current_project().ok().flatten();
    if sticky.as_deref() == Some(name) {
        "  Next:  moor next".to_string()
    } else {
        format!("  Next:  moor next --project {name}")
    }
}

/// `moor next`: where the project's active spec stands and the one
/// command that moves it on — see `guide`. `--all` lists every spec.
pub fn run(explicit: Option<String>, all: bool) -> Result<()> {
    let t = Target::resolve(explicit)?;
    let report = t.report()?;
    if all {
        let active = t.active(&report);
        println!("{} specs:", t.name);
        for line in guide::render_all(&report, active.as_ref()) {
            println!("{line}");
        }
    } else {
        t.print_guidance(&report);
    }
    Ok(())
}