roundabout

public

Star0

Fork 0

Watch0

14 commits 1 branch 0 tags 0 releases158.8 KiB

Commit `9117440444eb`

tarball

atagen <boss@atagen.co>2026-10-26 02:57 UTC

4 files changed+152-2

add .resrc support

Modified file: README.md+12 additions@@ -73,6 +73,18 @@ restart omp after linking. install `.#roundabout` on PATH for the agent's bash t
 
 `~/.config/roundabout/config.toml`, falling back to `/etc/roundabout/config.toml`, or `$ROUNDABOUT_CONFIG` over both. the daemon picks up edits on save, on linux anyway. a broken config gets complained about and ignored rather than taking every agent down with it. everything's optional, these are the defaults
 
+project settings can live in a hidden `.resrc` file. each client command starts in its current directory and walks upward until it reaches the git root. the first `.resrc` it finds wins, so a nested file takes precedence over one at the repository root. directories outside a git worktree do not load a project file. `.resrc` uses the same TOML settings, and omitted values keep the user or system settings
+
+```toml
+# .resrc
+[budget]
+ram = "16GiB"
+cores = 8
+
+[artifacts]
+project_cap = "20GiB"
+```
+
 ```toml
 [budget]
 ram = "75%"            # of total, or "24GiB"

Modified file: src/config.rs+67 additions@@ -349,6 +349,33 @@ impl Config {
         }
     }
 
+    pub fn load_for(cwd: &std::path::Path) -> Result<Self, String> {
+        let global = paths::config_file();
+        let mut base = match fs::read_to_string(&global) {
+            Ok(text) => toml::from_str(&text).map_err(|e| format!("{}: {e}", global.display()))?,
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
+                toml::Value::Table(toml::map::Map::new())
+            }
+            Err(e) => return Err(format!("{}: {e}", global.display())),
+        };
+        if let Some(path) = paths::project_config_file(cwd) {
+            let text = fs::read_to_string(&path).map_err(|e| format!("{}: {e}", path.display()))?;
+            let overlay: toml::Value =
+                toml::from_str(&text).map_err(|e| format!("{}: {e}", path.display()))?;
+            if !overlay.is_table() {
+                return Err(format!("{}: expected a TOML table", path.display()));
+            }
+            merge_values(&mut base, overlay);
+        }
+        let mut config: Self = base
+            .try_into()
+            .map_err(|e| format!("{}: {e}", global.display()))?;
+        for (name, preset) in Self::default().sizes {
+            config.sizes.entry(name).or_insert(preset);
+        }
+        Ok(config)
+    }
+
     pub fn parse(text: &str) -> Result<Self, toml::de::Error> {
         let mut config: Self = toml::from_str(text)?;
         for (name, preset) in Self::default().sizes {
@@ -382,3 +409,43 @@ impl Config {
             .map(String::as_str)
     }
 }
+
+fn merge_values(base: &mut toml::Value, overlay: toml::Value) {
+    match overlay {
+        toml::Value::Table(overlay) => {
+            if let toml::Value::Table(base) = base {
+                for (key, value) in overlay {
+                    if let Some(existing) = base.get_mut(&key) {
+                        merge_values(existing, value);
+                    } else {
+                        base.insert(key, value);
+                    }
+                }
+            } else {
+                *base = toml::Value::Table(overlay);
+            }
+        }
+        value => *base = value,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Config, merge_values};
+    use crate::units::Bytes;
+
+    #[test]
+    fn project_values_override_individual_defaults() {
+        let mut base: toml::Value = toml::from_str(
+            "[budget]\nram = \"60%\"\nram_reserve = \"2GiB\"\n[queue]\nelastic = false\n",
+        )
+        .expect("parse global config");
+        let project: toml::Value =
+            toml::from_str("[budget]\nram_reserve = \"8GiB\"\n").expect("parse project config");
+        merge_values(&mut base, project);
+        let config: Config = base.try_into().expect("decode merged config");
+        assert_eq!(config.budget.ram_reserve, Bytes::gib(8));
+        assert_eq!(config.budget.ram, "60%".parse().expect("parse amount"));
+        assert!(!config.queue.elastic);
+    }
+}

Modified file: src/main.rs+9 additions−2 deletions@@ -24,9 +24,16 @@ fn main() {
     }
     // a typo must not exit 2, that's a blocking pretooluse verdict and would
     // wall off every bash call in every session
-    let cfg = config::Config::load().unwrap_or_else(|e| {
+    let rabt = cli::Rabt::parse();
+    let cfg = if matches!(&rabt, cli::Rabt::Daemon) {
+        config::Config::load()
+    } else {
+        let cwd = std::env::current_dir().unwrap_or_else(|_| "/".into());
+        config::Config::load_for(&cwd)
+    }
+    .unwrap_or_else(|e| {
         eprintln!("roundabout: bad config, using defaults. {e}");
         config::Config::default()
     });
-    std::process::exit(cli::dispatch(&cfg, cli::Rabt::parse()));
+    std::process::exit(cli::dispatch(&cfg, rabt));
 }

Modified file: src/paths.rs+64 additions@@ -67,6 +67,25 @@ pub fn spawn_lock() -> PathBuf {
     runtime_dir().join("roundabout.lock")
 }
 
+pub fn git_root(cwd: &Path) -> Option<PathBuf> {
+    cwd.ancestors()
+        .find(|dir| dir.join(".git").exists())
+        .map(Path::to_path_buf)
+}
+
+pub fn project_config_file(cwd: &Path) -> Option<PathBuf> {
+    let root = git_root(cwd)?;
+    for dir in cwd.ancestors() {
+        if dir.join(".resrc").is_file() {
+            return Some(dir.join(".resrc"));
+        }
+        if dir == root {
+            break;
+        }
+    }
+    None
+}
+
 pub fn project_root(cwd: &Path) -> PathBuf {
     const MARKERS: [&str; 6] = [
         ".jj",
@@ -87,3 +106,48 @@ pub fn project_root(cwd: &Path) -> PathBuf {
     }
     best.unwrap_or_else(|| cwd.to_path_buf())
 }
+
+#[cfg(test)]
+mod tests {
+    use std::{
+        fs,
+        path::PathBuf,
+        time::{SystemTime, UNIX_EPOCH},
+    };
+
+    use super::project_config_file;
+
+    fn temp_tree() -> PathBuf {
+        let stamp = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("clock before epoch")
+            .as_nanos();
+        let root = std::env::temp_dir().join(format!("roundabout-paths-{stamp}"));
+        fs::create_dir_all(&root).expect("create temporary tree");
+        root
+    }
+
+    #[test]
+    fn project_config_is_nearest_and_git_bounded() {
+        let outer = temp_tree();
+        let root = outer.join("repo");
+        fs::create_dir(&root).expect("create repository tree");
+        let child = root.join("child");
+        let nested = child.join("nested");
+        fs::create_dir_all(&nested).expect("create nested tree");
+        fs::create_dir(root.join(".git")).expect("create git marker");
+        fs::write(root.join(".resrc"), "").expect("write root config");
+        fs::write(child.join(".resrc"), "").expect("write child config");
+        fs::write(nested.join(".resrc"), "").expect("write nested config");
+        assert_eq!(project_config_file(&nested), Some(nested.join(".resrc")));
+        fs::remove_file(nested.join(".resrc")).expect("remove nested config");
+        assert_eq!(project_config_file(&nested), Some(child.join(".resrc")));
+        fs::remove_file(child.join(".resrc")).expect("remove child config");
+        assert_eq!(project_config_file(&nested), Some(root.join(".resrc")));
+        fs::remove_file(root.join(".resrc")).expect("remove root config");
+        fs::write(outer.join(".resrc"), "").expect("write outside config");
+        assert_eq!(project_config_file(&nested), None);
+        fs::remove_file(outer.join(".resrc")).expect("remove outside config");
+        fs::remove_dir_all(outer).expect("remove temporary tree");
+    }
+}

roundabout

Commit 9117440444eb

Commit `9117440444eb`