opencrabs 0.3.25

The autonomous, self-improving AI agent. Single Rust binary. Every channel. Install with: cargo install opencrabs
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

//! Rebuild Tool
//!
//! Lets the agent build OpenCrabs from source and exec() restart automatically.
//! The build runs via `SelfUpdater::build_streaming` — progress lines are forwarded
//! through the ProgressCallback so the TUI shows them live.  On success, a
//! `ProgressEvent::RestartReady` is emitted which triggers an automatic exec() restart
//! (no user prompt needed).

use super::error::Result;
use super::r#trait::{Tool, ToolCapability, ToolExecutionContext, ToolResult};
use crate::brain::SelfUpdater;
use crate::brain::agent::{ProgressCallback, ProgressEvent};
use async_trait::async_trait;
use serde_json::Value;

/// Agent-callable tool that builds the project and auto-restarts via exec().
pub struct RebuildTool {
    progress: Option<ProgressCallback>,
}

impl RebuildTool {
    pub fn new(progress: Option<ProgressCallback>) -> Self {
        Self { progress }
    }
}

#[async_trait]
impl Tool for RebuildTool {
    fn name(&self) -> &str {
        "rebuild"
    }

    fn description(&self) -> &str {
        "Build OpenCrabs from source (cargo build --release) and signal the TUI to hot-restart. \
         Call this after editing source code to apply your changes. On success the binary is \
         exec()-replaced automatically (no prompt). On failure the compiler output is returned."
    }

    fn input_schema(&self) -> Value {
        serde_json::json!({
            "type": "object",
            "properties": {},
            "required": []
        })
    }

    fn capabilities(&self) -> Vec<ToolCapability> {
        vec![ToolCapability::SystemModification]
    }

    async fn execute(&self, _input: Value, context: &ToolExecutionContext) -> Result<ToolResult> {
        let updater = match SelfUpdater::auto_detect() {
            Ok(u) => u,
            Err(e) => {
                return Ok(ToolResult::error(format!(
                    "Cannot detect project root: {}",
                    e
                )));
            }
        };

        let cb = self.progress.clone();
        let sid = context.session_id;

        // Stream build progress as rolling build lines (TUI shows last ~6)
        let result = updater
            .build_streaming(move |line| {
                let trimmed = line.trim();
                // Forward meaningful cargo lines as build progress
                if (trimmed.starts_with("Compiling")
                    || trimmed.starts_with("Finished")
                    || trimmed.starts_with("error")
                    || trimmed.starts_with("warning[")
                    || trimmed.starts_with("-->"))
                    && let Some(ref cb) = cb
                {
                    cb(sid, ProgressEvent::BuildLine(line));
                }
            })
            .await;

        match result {
            Ok(path) => {
                // Signal auto-restart — TuiEvent::RestartReady triggers exec() with no prompt
                if let Some(ref cb) = self.progress {
                    cb(
                        sid,
                        ProgressEvent::RestartReady {
                            status: format!("Build successful: {}", path.display()),
                        },
                    );
                }
                Ok(ToolResult::success(format!(
                    "Build successful: {}. Restarting now.",
                    path.display()
                )))
            }
            Err(output) => Ok(ToolResult::error(format!("Build failed:\n{}", output))),
        }
    }
}