resuma 1.1.0

Resuma — resumable SSR Rust web framework: zero hydration, islands, server actions, Flow (Axum).
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

//! Execution planner — intent → [`ExecutionPlan`].

use super::types::{ExecutionPlan, ExecutionStrategy, RuntimeChoice};

/// Heuristic planner (static analysis + intent keywords).
///
/// Future: AST pass over worker body to detect `ctx.tool` / `ctx.ai` calls.
pub fn plan(intent: &str, hints: PlannerHints) -> ExecutionPlan {
    let lower = intent.to_lowercase();
    let words = lower.split_whitespace().count();

    let use_ai = hints.use_ai
        || lower.contains("ai")
        || lower.contains("analiz")
        || lower.contains("classif")
        || lower.contains("analyze");

    let heavy = lower.contains("1m")
        || lower.contains("1000")
        || lower.contains("millón")
        || lower.contains("million")
        || words > 12;

    let strategy = if heavy && use_ai {
        ExecutionStrategy::MapReduce
    } else if lower.contains(" || ") || lower.contains(" parallel") {
        ExecutionStrategy::Parallel
    } else if lower.contains(" → ") || lower.contains(" then ") || lower.contains(" luego ") {
        ExecutionStrategy::Pipeline
    } else if hints.tools.len() > 2 {
        ExecutionStrategy::Hybrid
    } else {
        ExecutionStrategy::Single
    };

    let chunks = match strategy {
        ExecutionStrategy::MapReduce => 5,
        ExecutionStrategy::Parallel => 3,
        ExecutionStrategy::Hybrid => 2,
        _ => 1,
    };

    let parallel = matches!(
        strategy,
        ExecutionStrategy::Parallel | ExecutionStrategy::MapReduce
    );

    let runtime = if heavy || use_ai {
        RuntimeChoice::Backend
    } else {
        RuntimeChoice::Auto
    };

    let estimated_cost = if heavy {
        Some("high".into())
    } else if use_ai {
        Some("medium".into())
    } else {
        Some("low".into())
    };

    ExecutionPlan {
        runtime,
        strategy,
        chunks,
        parallel,
        use_ai,
        tools: hints.tools,
        estimated_cost,
    }
}

#[derive(Debug, Clone, Default)]
pub struct PlannerHints {
    pub use_ai: bool,
    pub tools: Vec<String>,
}