gbd 1.8.3

The Beads agent workflow on GitHub Issues and Projects
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
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

//! Optional `.gbd.yml` in the repo root.

use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
use std::fmt::Write as _;
use std::fs;
use std::path::{Path, PathBuf};

#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct Config {
    #[serde(default)]
    pub repo: Option<String>,
    #[serde(default)]
    pub memory_issue: Option<u64>,
    /// GitHub Project number under the repo's owner (the board).
    #[serde(default)]
    pub project: Option<u64>,
}

impl Config {
    pub fn project_number(&self) -> Option<u64> {
        self.project
    }

    pub fn parse(text: &str) -> Result<Self> {
        let mut cfg = Config::default();
        for line in text.lines() {
            let line = line.trim();
            if line.is_empty() || line.starts_with('#') {
                continue;
            }
            let Some((k, v)) = line.split_once(':') else {
                continue;
            };
            let k = k.trim();
            let v = v.trim().trim_matches('"').trim_matches('\'');
            match k {
                "repo" if !v.is_empty() && v != "null" => cfg.repo = Some(v.to_string()),
                "memory_issue" if !v.is_empty() && v != "null" => {
                    cfg.memory_issue = Some(v.parse().context("memory_issue")?);
                }
                "project" if !v.is_empty() && v != "null" => {
                    cfg.project = Some(v.parse().context("project (must be the board's number)")?);
                }
                _ => {}
            }
        }
        Ok(cfg)
    }

    pub fn render(&self) -> String {
        let mut out = String::from("# gbd config. Commit this file.\n");
        if let Some(r) = &self.repo {
            let _ = writeln!(out, "repo: {r}");
        }
        if let Some(n) = self.memory_issue {
            let _ = writeln!(out, "memory_issue: {n}");
        }
        if let Some(p) = self.project {
            let _ = writeln!(out, "project: {p}");
        }
        out
    }

    pub fn load_from(path: &Path) -> Result<Self> {
        let text =
            fs::read_to_string(path).with_context(|| format!("reading {}", path.display()))?;
        Self::parse(&text).with_context(|| format!("parsing {}", path.display()))
    }

    pub fn save_to(&self, path: &Path) -> Result<()> {
        fs::write(path, self.render()).with_context(|| format!("writing {}", path.display()))?;
        Ok(())
    }
}

/// Walk from `start` toward filesystem root looking for `.gbd.yml`.
pub fn find_from(start: &Path) -> Option<PathBuf> {
    let mut dir = start.to_path_buf();
    loop {
        let candidate = dir.join(".gbd.yml");
        if candidate.is_file() {
            return Some(candidate);
        }
        if !dir.pop() {
            return None;
        }
    }
}

pub fn find() -> Option<PathBuf> {
    std::env::current_dir().ok().and_then(|cwd| find_from(&cwd))
}

pub fn load() -> Result<Config> {
    match find() {
        Some(path) => Config::load_from(&path),
        None => Ok(Config::default()),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;

    #[test]
    fn round_trip() {
        let dir = tempfile::tempdir().unwrap();
        let path = dir.path().join(".gbd.yml");
        let cfg = Config {
            repo: Some("acme/widgets".into()),
            memory_issue: Some(7),
            project: None,
        };
        cfg.save_to(&path).unwrap();
        let loaded = Config::load_from(&path).unwrap();
        assert_eq!(cfg, loaded);
    }

    #[test]
    fn parse_comments_and_quotes() {
        let cfg = Config::parse("repo: 'acme/widgets'\n# hi\nmemory_issue: 12\n").unwrap();
        assert_eq!(cfg.repo.as_deref(), Some("acme/widgets"));
        assert_eq!(cfg.memory_issue, Some(12));
    }

    #[test]
    fn project_must_be_a_number() {
        assert_eq!(Config::parse("project: 8\n").unwrap().project, Some(8));
        let err = Config::parse("project: abc\n").unwrap_err();
        assert!(format!("{err:#}").contains("project"), "{err:#}");
        assert!(Config::parse("memory_issue: abc\n").is_err());
    }

    #[test]
    fn find_walks_up() {
        let dir = tempfile::tempdir().unwrap();
        let nested = dir.path().join("a/b");
        fs::create_dir_all(&nested).unwrap();
        fs::write(dir.path().join(".gbd.yml"), "repo: a/b\n").unwrap();
        let found = find_from(&nested).unwrap();
        assert_eq!(found, dir.path().join(".gbd.yml"));
    }
}