ralph-workflow 0.7.18

PROMPT-driven multi-agent orchestrator for git repos
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

//! Idle-timeout monitor thread.
//!
//! Split into focused modules:
//! - `base`: MonitorConfig, MonitorResult, MonitorParams, MonitorLoopState
//! - `sleep`: sleep utilities
//! - `core`: enforcement and policy logic

pub mod base;
pub mod core;
pub mod sleep;

// Re-export public types from submodules for convenient access
pub use base::FileActivityConfig;
pub use base::MonitorConfig;
pub use base::MonitorResult;

use crate::executor::AgentChild;
use crate::pipeline::idle_timeout::SharedActivityTimestamp;

/// Like [`monitor_idle_timeout_with_interval_and_kill_config`] but with only timeout and check interval.
pub fn monitor_idle_timeout_with_interval(
    activity_timestamp: &SharedActivityTimestamp,
    child: &std::sync::Arc<std::sync::Mutex<Box<dyn AgentChild>>>,
    timeout: std::time::Duration,
    should_stop: &std::sync::Arc<std::sync::atomic::AtomicBool>,
    executor: &std::sync::Arc<dyn crate::executor::ProcessExecutor>,
    check_interval: std::time::Duration,
) -> MonitorResult {
    monitor_idle_timeout_with_interval_and_kill_config(
        activity_timestamp,
        None,
        child,
        should_stop,
        executor,
        MonitorConfig {
            timeout,
            check_interval,
            kill_config: crate::pipeline::idle_timeout::io::DEFAULT_KILL_CONFIG,
            ..Default::default()
        },
    )
}

pub fn monitor_idle_timeout_with_interval_and_kill_config(
    activity_timestamp: &SharedActivityTimestamp,
    file_activity_config: Option<&FileActivityConfig>,
    child: &std::sync::Arc<std::sync::Mutex<Box<dyn AgentChild>>>,
    should_stop: &std::sync::Arc<std::sync::atomic::AtomicBool>,
    executor: &std::sync::Arc<dyn crate::executor::ProcessExecutor>,
    config: MonitorConfig,
) -> MonitorResult {
    monitor_idle_timeout_with_interval_and_kill_config_and_observer(
        activity_timestamp,
        file_activity_config,
        child,
        should_stop,
        executor,
        config,
        None,
    )
}

pub fn monitor_idle_timeout_with_interval_and_kill_config_and_observer(
    activity_timestamp: &SharedActivityTimestamp,
    file_activity_config: Option<&FileActivityConfig>,
    child: &std::sync::Arc<std::sync::Mutex<Box<dyn AgentChild>>>,
    should_stop: &std::sync::Arc<std::sync::atomic::AtomicBool>,
    executor: &std::sync::Arc<dyn crate::executor::ProcessExecutor>,
    config: MonitorConfig,
    child_activity_suppressed: Option<
        &std::sync::Arc<std::sync::Mutex<Option<crate::executor::ChildProcessInfo>>>,
    >,
) -> MonitorResult {
    let params = base::MonitorParams {
        activity_timestamp,
        file_activity_config,
        child,
        should_stop,
        executor,
        child_activity_suppressed,
        timeout: config.timeout,
        check_interval: config.check_interval,
        kill_config: config.kill_config,
        required_idle_confirmations: config.required_idle_confirmations,
        check_child_processes: config.check_child_processes,
        completion_check: config.completion_check,
        partial_completion_check: config.partial_completion_check,
        tool_activity_check: config.tool_activity_check,
        max_tool_suppression_ticks: config.max_tool_suppression_ticks,
    };
    run_monitor_loop(&params)
}

fn run_monitor_loop(params: &base::MonitorParams<'_>) -> MonitorResult {
    let mut s = base::MonitorLoopState::new();
    loop {
        if let base::MonitorLoopAction::Return(r) = core::handle_enforcement_tick(params, &mut s) {
            return r;
        }
    }
}