macot 0.1.11

Multi Agent Control Tower - CLI for orchestrating Claude CLI instances
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

use anyhow::{Context, Result};
use clap::Args as ClapArgs;
use std::path::PathBuf;

use crate::commands::common;
use crate::config::Config;
use crate::session::{TmuxManager, WorktreeManager};
use crate::tower::TowerApp;
use crate::utils::path_to_str;

#[derive(ClapArgs)]
pub struct Args {
    /// Path to project directory (default: current directory)
    #[arg(default_value = ".")]
    pub project_path: PathBuf,

    /// Number of experts (overrides config)
    #[arg(short = 'n', long)]
    pub num_experts: Option<u32>,

    /// Custom config file path
    #[arg(short, long)]
    pub config: Option<PathBuf>,
}

pub async fn execute(args: Args) -> Result<()> {
    let project_path = args
        .project_path
        .canonicalize()
        .context("Failed to resolve project path")?;

    println!("Launching macot session for: {}", project_path.display());

    let mut config = Config::load(args.config)?.with_project_path(project_path.clone());

    if let Some(n) = args.num_experts {
        config = config.with_num_experts(n);
    }

    let tmux = TmuxManager::from_config(&config);

    if tmux.session_exists().await {
        println!("Attaching to existing session: {}", config.session_name());
        let metadata = tmux.load_session_metadata().await?;
        if args.num_experts.is_none() {
            match metadata.num_experts {
                Some(n) => config = config.with_num_experts(n),
                None => {
                    tracing::warn!("Session metadata missing num_experts; using config default")
                }
            }
        }
        println!("Number of experts: {}", config.num_experts());
        let worktree_manager = WorktreeManager::resolve(project_path).await?;
        let mut app = TowerApp::new(config, worktree_manager);
        app.run().await?;
        return Ok(());
    }

    println!("Creating session: {}", config.session_name());
    println!("Number of experts: {}", config.num_experts());

    let managers = common::init_session(&config, &project_path).await?;

    let config_clone = config.clone();
    let tmux_clone = managers.tmux.clone();
    let claude_clone = managers.claude.clone();
    let working_dir = path_to_str(&project_path)?.to_string();

    tokio::spawn(async move {
        let config = config_clone;
        let tmux = tmux_clone;
        let claude = claude_clone;

        for (i, expert) in config.experts.iter().enumerate() {
            let expert_id = i as u32;
            let expert_name = expert.name.clone();
            let working_dir = working_dir.clone();
            let timeout = config.timeouts.agent_ready;

            let (instruction_file, agents_file, settings_file) =
                match common::prepare_expert_files(&config, expert_id) {
                    Ok(files) => files,
                    Err(e) => {
                        eprintln!("Failed to prepare files for expert {expert_id}: {e}");
                        continue;
                    }
                };

            if let Err(e) = tmux.set_pane_title(expert_id, &expert_name).await {
                eprintln!("Failed to set pane title for expert {expert_id}: {e}");
            }

            if let Err(e) = claude
                .launch_claude(
                    expert_id,
                    &working_dir,
                    instruction_file.as_deref(),
                    agents_file.as_deref(),
                    settings_file.as_deref(),
                )
                .await
            {
                eprintln!("Failed to launch Claude for expert {expert_id}: {e}");
                continue;
            }

            match claude.wait_for_ready(expert_id, timeout).await {
                Ok(true) => {
                    tracing::info!("Expert {} ({}) ready", expert_id, expert_name);
                }
                Ok(false) => {
                    tracing::warn!("Expert {} ({}) timeout", expert_id, expert_name);
                }
                Err(e) => {
                    tracing::error!("Expert {} ({}) failed: {}", expert_id, expert_name, e);
                }
            }
        }
    });

    println!("Session infrastructure ready. Launching experts in background...");

    let worktree_manager = WorktreeManager::resolve(project_path).await?;
    let mut app = TowerApp::new(config, worktree_manager);
    app.run().await?;

    Ok(())
}