brainwires-autonomy 0.8.0

Autonomous agent operations — self-improvement, Git workflows, and human-out-of-loop execution
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

//! Test coverage detection strategy.

use anyhow::Result;
use async_trait::async_trait;
use walkdir::WalkDir;

use super::{ImprovementCategory, ImprovementStrategy, ImprovementTask};
use crate::config::StrategyConfig;

/// Strategy that identifies source files without any test coverage.
///
/// Scans for Rust files in `src/` that lack `#[cfg(test)]` or `#[test]` blocks
/// and have public functions, then generates tasks to add unit tests.
pub struct TestCoverageStrategy;

#[async_trait]
impl ImprovementStrategy for TestCoverageStrategy {
    fn name(&self) -> &str {
        "test_coverage"
    }

    fn category(&self) -> ImprovementCategory {
        ImprovementCategory::Testing
    }

    async fn generate_tasks(
        &self,
        repo_path: &str,
        config: &StrategyConfig,
    ) -> Result<Vec<ImprovementTask>> {
        let src_path = format!("{repo_path}/src");
        let mut uncovered: Vec<(String, Vec<String>)> = Vec::new();

        for entry in WalkDir::new(&src_path)
            .into_iter()
            .filter_map(|e| e.ok())
            .filter(|e| e.path().extension().is_some_and(|ext| ext == "rs"))
        {
            let path = entry.path();
            let content = match std::fs::read_to_string(path) {
                Ok(c) => c,
                Err(_) => continue,
            };

            let rel_path = path
                .strip_prefix(repo_path)
                .unwrap_or(path)
                .to_string_lossy()
                .to_string();

            if rel_path.contains("/tests/") || rel_path.ends_with("mod.rs") {
                continue;
            }

            let has_tests = content.contains("#[cfg(test)]") || content.contains("#[test]");

            if !has_tests {
                let pub_fns: Vec<String> = content
                    .lines()
                    .filter(|line| {
                        let trimmed = line.trim();
                        trimmed.starts_with("pub fn ") || trimmed.starts_with("pub async fn ")
                    })
                    .map(|line| {
                        line.trim()
                            .split('(')
                            .next()
                            .unwrap_or("")
                            .replace("pub fn ", "")
                            .replace("pub async fn ", "")
                            .trim()
                            .to_string()
                    })
                    .filter(|name| !name.is_empty())
                    .collect();

                if !pub_fns.is_empty() {
                    uncovered.push((rel_path, pub_fns));
                }
            }
        }

        let mut tasks: Vec<ImprovementTask> = uncovered
            .into_iter()
            .take(config.max_tasks_per_strategy)
            .enumerate()
            .map(|(i, (file, fns))| {
                let fn_count = fns.len();
                let context = format!(
                    "Public functions without tests:\n{}",
                    fns.iter()
                        .map(|f| format!("  - {f}"))
                        .collect::<Vec<_>>()
                        .join("\n")
                );

                ImprovementTask {
                    id: format!("test-{i}"),
                    strategy: "test_coverage".to_string(),
                    category: ImprovementCategory::Testing,
                    description: format!(
                        "Add unit tests for {fn_count} public function(s) in {file}. \
                         Add a #[cfg(test)] module at the bottom of the file with \
                         tests for the key public functions. Focus on testing the \
                         happy path and one or two edge cases per function."
                    ),
                    target_files: vec![file],
                    priority: 5,
                    estimated_diff_lines: (fn_count * 15) as u32,
                    context,
                }
            })
            .collect();

        tasks.sort_by(|a, b| b.priority.cmp(&a.priority));
        Ok(tasks)
    }
}