wauldo 0.2.0

Official Rust SDK for Wauldo — Verified AI answers from your documents
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

//! Task planning methods for AgentClient

use std::sync::OnceLock;

use regex::Regex;
use serde_json::json;

use crate::error::{Error, Result};
use crate::types::*;

use super::AgentClient;

/// Compiled regex for step detection — anchored to avoid false positives
fn step_pattern() -> &'static Regex {
    static RE: OnceLock<Regex> = OnceLock::new();
    RE.get_or_init(|| Regex::new(r"^(\d+)\.\s+(.+)$").expect("valid regex"))
}

impl AgentClient {
    /// Plan a task
    pub async fn plan_task(&mut self, task: &str) -> Result<PlanResult> {
        self.plan_task_with_options(task, PlanOptions::default())
            .await
    }

    /// Plan a task with options
    pub async fn plan_task_with_options(
        &mut self,
        task: &str,
        options: PlanOptions,
    ) -> Result<PlanResult> {
        if task.trim().is_empty() {
            return Err(Error::validation_field("Task cannot be empty", "task"));
        }

        let max_steps = options.max_steps.unwrap_or(10);
        if !(1..=20).contains(&max_steps) {
            return Err(Error::validation_field(
                "max_steps must be between 1 and 20",
                "max_steps",
            ));
        }

        let detail_level = match options.detail_level.unwrap_or_default() {
            DetailLevel::Brief => "brief",
            DetailLevel::Normal => "normal",
            DetailLevel::Detailed => "detailed",
        };

        let content = self
            .call_tool(
                "plan_task",
                json!({
                    "task": task,
                    "context": options.context.unwrap_or_default(),
                    "max_steps": max_steps,
                    "detail_level": detail_level
                }),
            )
            .await?;

        Ok(self.parse_plan_result(&content, task))
    }

    pub(crate) fn parse_plan_result(&self, content: &str, task: &str) -> PlanResult {
        // Try JSON first (structured output from server v0.2+)
        if let Ok(data) = serde_json::from_str::<serde_json::Value>(content) {
            if let Some(steps_arr) = data.get("steps").and_then(|s| s.as_array()) {
                let steps = steps_arr
                    .iter()
                    .map(|s| PlanStep {
                        number: s["number"].as_u64().unwrap_or(0) as usize,
                        title: s["title"].as_str().unwrap_or("").to_string(),
                        description: s["description"].as_str().unwrap_or("").to_string(),
                        priority: s["priority"].as_str().unwrap_or("Medium").to_string(),
                        effort: s["effort"].as_str().unwrap_or("").to_string(),
                        dependencies: s["dependencies"]
                            .as_array()
                            .map(|a| a.iter().filter_map(|v| v.as_str().map(String::from)).collect())
                            .unwrap_or_default(),
                    })
                    .collect();
                return PlanResult {
                    task: data["task"].as_str().unwrap_or(task).to_string(),
                    category: data["category"].as_str().unwrap_or("General").to_string(),
                    steps,
                    total_effort: data["total_effort"].as_str().unwrap_or("").to_string(),
                    raw_content: content.to_string(),
                };
            }
        }

        // Fallback: markdown heuristic parser (server v0.1.x)
        let mut steps = Vec::new();
        let mut category = "General".to_string();
        let mut total_effort = String::new();
        let mut current_step = 0;

        for line in content.lines() {
            let trimmed = line.trim();

            // Extract category: "**Category**: X" → take everything after the first ':'
            if let Some(rest) = trimmed.strip_prefix("**Category**:") {
                category = rest.trim().to_string();
                if category.is_empty() {
                    category = "General".to_string();
                }
                continue;
            }

            // Match numbered steps strictly: "1. Title" via anchored regex
            if let Some(caps) = step_pattern().captures(trimmed) {
                current_step += 1;
                let title = caps[2].trim().to_string();
                if !title.is_empty() {
                    steps.push(PlanStep {
                        number: current_step,
                        title,
                        description: String::new(),
                        priority: "Medium".to_string(),
                        effort: String::new(),
                        dependencies: vec![],
                    });
                }
                continue;
            }

            // Extract effort
            if let Some(rest) = trimmed.strip_prefix("**Estimated total effort**:") {
                total_effort = rest.trim().to_string();
            }
        }

        PlanResult {
            task: task.to_string(),
            category,
            steps,
            total_effort,
            raw_content: content.to_string(),
        }
    }
}