malvin 0.2.4

Non-interactive research and coding agent
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

use crate::artifacts::{RunArtifacts, SessionDotfileBackups};
use crate::cli::workflow_router_shared::run_router_workspace_gates;
use crate::router_flow::router_flow_acp::RouterExitSummarize;

pub(crate) enum RouterLoopDecision {
    Continue,
    Exit,
    ExitGatesFailed(String),
}

pub(crate) struct RouterLoopExitInput<'a> {
    pub artifacts: &'a RunArtifacts,
    pub backups: &'a SessionDotfileBackups,
    pub done: bool,
    pub gates: bool,
    pub agent_loop: usize,
    pub max_loops: usize,
}

pub(crate) fn decide_router_loop_exit(input: RouterLoopExitInput<'_>) -> RouterLoopDecision {
    if input.done {
        if input.gates {
            return decide_router_gates_exit(
                input.artifacts,
                input.backups,
                input.agent_loop,
                input.max_loops,
            );
        }
        return RouterLoopDecision::Exit;
    }
    decide_router_loop_exit_not_done(input.agent_loop, input.max_loops)
}

pub(crate) fn decide_router_gates_exit(
    artifacts: &RunArtifacts,
    backups: &SessionDotfileBackups,
    agent_loop: usize,
    max_loops: usize,
) -> RouterLoopDecision {
    crate::gate_loop_session::set_active_gate_iteration(Some(agent_loop));
    let decision = match run_router_workspace_gates(artifacts, backups, true) {
        Ok(()) => RouterLoopDecision::Exit,
        Err(detail) if agent_loop == max_loops => RouterLoopDecision::ExitGatesFailed(detail),
        Err(_) => RouterLoopDecision::Continue,
    };
    crate::gate_loop_session::set_active_gate_iteration(None);
    decision
}

pub(crate) const fn decide_router_loop_exit_not_done(
    agent_loop: usize,
    max_loops: usize,
) -> RouterLoopDecision {
    if agent_loop == max_loops {
        RouterLoopDecision::Exit
    } else {
        RouterLoopDecision::Continue
    }
}

pub(crate) const fn router_exit_summarize_for(
    decision: &RouterLoopDecision,
) -> RouterExitSummarize {
    match decision {
        RouterLoopDecision::Continue => RouterExitSummarize::Skip,
        RouterLoopDecision::Exit | RouterLoopDecision::ExitGatesFailed(_) => {
            RouterExitSummarize::Run
        }
    }
}