agentool 0.1.0

Rust toolkit for AI agents: JSON Schema-defined tools for workspace files, search, web, Markdown, Git, memory, human-in-the-loop hooks, and todos.
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

use std::sync::Arc;

use async_trait::async_trait;
use serde_json::{json, Value};

use crate::core::blocking::run_blocking;
use crate::{Tool, ToolResult};

use super::ops;
use super::MdContext;

macro_rules! md_tool {
    (
        $name:ident, $tool_name:literal, $desc:literal,
        schema = $schema:expr,
        op = $op:ident
    ) => {
        pub struct $name {
            ctx: Arc<MdContext>,
        }

        impl $name {
            pub fn new(ctx: Arc<MdContext>) -> Self {
                Self { ctx }
            }
        }

        #[async_trait]
        impl Tool for $name {
            fn name(&self) -> &str {
                $tool_name
            }

            fn description(&self) -> &str {
                $desc
            }

            fn schema(&self) -> Value {
                $schema
            }

            async fn execute(&self, params: Value) -> ToolResult {
                let ctx = self.ctx.clone();
                run_blocking(move || ops::$op(&ctx, &params)).await
            }
        }
    };
}

md_tool!(
    ExtractTocTool,
    "extract_toc",
    "Extract ATX heading outline (# .. ######) from a Markdown file. Headings inside fenced code blocks are ignored. Paths resolve against the context root; sandbox mode keeps reads inside the workspace.",
    schema = json!({
        "type": "object",
        "properties": {
            "path": { "type": "string", "description": "Path to the .md file (relative to workspace root or absolute in relaxed mode)" }
        },
        "required": ["path"]
    }),
    op = op_extract_toc
);

md_tool!(
    MarkdownStatsTool,
    "markdown_stats",
    "Non-whitespace character count, paragraph count (blank-line separated), ATX heading count, and line count for a Markdown file. Fenced code blocks are excluded from character and paragraph counts. Paths resolve like other workspace tools.",
    schema = json!({
        "type": "object",
        "properties": {
            "path": { "type": "string", "description": "Path to the Markdown file" }
        },
        "required": ["path"]
    }),
    op = op_markdown_stats
);

pub fn all_tools(ctx: Arc<MdContext>) -> Vec<Arc<dyn Tool>> {
    vec![
        Arc::new(ExtractTocTool::new(ctx.clone())),
        Arc::new(MarkdownStatsTool::new(ctx)),
    ]
}