cflx 0.6.82

Conflux – a spec-driven parallel coding orchestrator that runs AI agents on git worktrees
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
143
144
145
146
147
148
149

//! Terminal helper functions for TUI
//!
//! This module contains helper functions for terminal operations, extracted from runner.rs
//! to eliminate circular dependencies.

use crate::error::Result;
use crossterm::{
    event::DisableMouseCapture,
    execute,
    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
};
use ratatui::DefaultTerminal;
use std::path::Path;
use tracing::info;

use super::events::LogEntry;
use super::state::AppState;
use super::utils::clear_screen;

/// Restore terminal state (called on panic or normal exit)
pub fn restore_terminal() {
    // Always try to disable mouse capture, even if it wasn't enabled
    let _ = execute!(std::io::stdout(), DisableMouseCapture);
    let _ = clear_screen();
    ratatui::restore();
}

/// Execute a worktree command with terminal suspension and result logging
///
/// This helper executes a worktree command using AiCommandRunner, forwards output
/// to stdout/stderr, and logs the result to the app state.
pub async fn execute_worktree_command(
    terminal: &mut DefaultTerminal,
    command: &str,
    worktree_path: &Path,
    ai_runner: &crate::ai_command_runner::AiCommandRunner,
    app: &mut AppState,
) -> Result<()> {
    let command_clone = command.to_string();
    let worktree_path_clone = worktree_path.to_path_buf();
    let ai_runner_clone = ai_runner.clone();

    let status_result = suspend_terminal_and_execute(terminal, || async move {
        info!(
            module = module_path!(),
            "Running worktree command via AiCommandRunner: sh -c {}", command_clone
        );

        // Execute via AiCommandRunner (with stagger and retry)
        let exec_result = ai_runner_clone
            .execute_streaming_with_retry(&command_clone, Some(&worktree_path_clone), None, None)
            .await;

        match exec_result {
            Ok((mut child, mut rx)) => {
                // Forward output to stdout/stderr in real-time
                use crate::ai_command_runner::OutputLine;
                while let Some(line) = rx.recv().await {
                    match line {
                        OutputLine::Stdout(s) => {
                            println!("{}", s);
                        }
                        OutputLine::Stderr(s) => {
                            eprintln!("{}", s);
                        }
                    }
                }
                // Wait for child to complete
                child
                    .wait()
                    .await
                    .map_err(crate::error::OrchestratorError::Io)
            }
            Err(e) => {
                eprintln!("Failed to execute worktree command: {}", e);
                Err(e)
            }
        }
    })
    .await?;

    match status_result {
        exit_status if exit_status.success() => {
            app.add_log(LogEntry::success("Worktree command completed successfully"));
        }
        exit_status => {
            app.add_log(LogEntry::error(format!(
                "Worktree command failed with exit code: {:?}",
                exit_status.code()
            )));
        }
    }

    Ok(())
}

/// Suspend terminal, execute a function, then restore terminal
///
/// This helper encapsulates the pattern of:
/// 1. Disable raw mode and leave alternate screen
/// 2. Execute a function (which may interact with the terminal)
/// 3. Restore raw mode and alternate screen
async fn suspend_terminal_and_execute<F, Fut, T>(terminal: &mut DefaultTerminal, f: F) -> Result<T>
where
    F: FnOnce() -> Fut,
    Fut: std::future::Future<Output = Result<T>>,
{
    // Suspend TUI
    disable_raw_mode()?;
    execute!(std::io::stdout(), LeaveAlternateScreen, DisableMouseCapture)?;

    // Execute the provided function
    let result = f().await;

    // Restore TUI
    enable_raw_mode()?;
    execute!(
        std::io::stdout(),
        EnterAlternateScreen,
        crossterm::event::EnableMouseCapture
    )?;
    terminal.clear()?;

    result
}

/// Suspend terminal, execute a synchronous function, then restore terminal
pub fn suspend_terminal_and_execute_sync<F, T>(terminal: &mut DefaultTerminal, f: F) -> Result<T>
where
    F: FnOnce() -> Result<T>,
{
    // Suspend TUI
    disable_raw_mode()?;
    execute!(std::io::stdout(), LeaveAlternateScreen, DisableMouseCapture)?;

    // Execute the provided function
    let result = f();

    // Restore TUI
    enable_raw_mode()?;
    execute!(
        std::io::stdout(),
        EnterAlternateScreen,
        crossterm::event::EnableMouseCapture
    )?;
    terminal.clear()?;

    result
}