gitgrip 0.19.0

Multi-repo workflow tool - manage multiple git repositories as one
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184

//! TDD tests for tmux integration in gr spawn (#442).
//!
//! Tests 13-18 from the Mission Control test plan.
//! All tests mock tmux subprocess calls (unit tests).
//! Integration tests requiring real tmux are in a separate module.

use std::collections::HashMap;
use std::fs;
use std::path::PathBuf;
use tempfile::TempDir;

use gitgrip::core::agent_registry::{get_agent, register_agent};

// ---------------------------------------------------------------------------
// Test helpers
// ---------------------------------------------------------------------------

/// Simulated spawn state for testing without real tmux.
struct MockSpawnState {
    pub session_name: String,
    pub windows: Vec<String>,
    pub pipe_panes: HashMap<String, PathBuf>,
    pub team_db_entries: Vec<TeamDbEntry>,
}

/// Expected team.db entry after spawn.
struct TeamDbEntry {
    pub agent_id: String,
    pub tmux_target: String,
    pub pid: Option<u32>,
    pub status: String,
    pub log_path: PathBuf,
}

// ---------------------------------------------------------------------------
// Test 13: gr spawn creates named tmux session
// ---------------------------------------------------------------------------

#[test]
#[should_panic(expected = "not yet implemented")]
fn test_spawn_creates_tmux_session() {
    // gr spawn up should create a tmux session named after [spawn].session_name
    // from agents.toml (e.g. "synapt" or "conversa").
    let _session = create_tmux_session("synapt");
    // Verify: tmux has-session -t synapt returns 0
    unimplemented!("create_tmux_session not yet implemented")
}

// ---------------------------------------------------------------------------
// Test 14: each agent gets its own tmux window
// ---------------------------------------------------------------------------

#[test]
#[should_panic(expected = "not yet implemented")]
fn test_spawn_creates_window_per_agent() {
    // Each agent in agents.toml should get a tmux window named after the agent.
    // 4 agents → 4 windows: synapt:opus, synapt:atlas, synapt:apollo, synapt:sentinel
    let agents = vec!["opus", "atlas", "apollo", "sentinel"];
    let windows = create_agent_windows("synapt", &agents);
    assert_eq!(windows.len(), 4);
    for agent in &agents {
        assert!(
            windows.contains(&format!("synapt:{}", agent)),
            "Missing window for {}",
            agent
        );
    }
    unimplemented!("create_agent_windows not yet implemented")
}

// ---------------------------------------------------------------------------
// Test 15: each window has pipe-pane to output.log
// ---------------------------------------------------------------------------

#[test]
#[should_panic(expected = "not yet implemented")]
fn test_spawn_sets_pipe_pane() {
    // Each agent window should have tmux pipe-pane set to write stdout
    // to a log file at <log_dir>/<agent_id>/output.log.
    // This enables real-time output streaming via file tailing.
    let tmp = TempDir::new().unwrap();
    let log_dir = tmp.path().join("logs");

    let pipe_panes = setup_pipe_panes("synapt", &["opus", "atlas"], &log_dir);

    // Verify pipe-pane targets
    assert_eq!(
        pipe_panes.get("opus").unwrap(),
        &log_dir.join("opus-001").join("output.log")
    );
    assert_eq!(
        pipe_panes.get("atlas").unwrap(),
        &log_dir.join("atlas-001").join("output.log")
    );
    unimplemented!("setup_pipe_panes not yet implemented")
}

// ---------------------------------------------------------------------------
// Test 16: PID, tmux_target, session_id written to team.db
// ---------------------------------------------------------------------------

#[test]
fn test_spawn_registers_in_team_db() {
    // After spawn, team.db should have process columns for each agent:
    // tmux_target (e.g. "synapt:opus"), pid, status ("online"), log_path.
    let tmp = TempDir::new().unwrap();
    let org_dir = tmp.path().join("synapt-dev");
    fs::create_dir_all(&org_dir).unwrap();

    // Register agent (this part works from Sprint 8)
    let agent_id = register_agent(&org_dir, "synapt-dev", "opus", Some("CEO")).unwrap();
    assert_eq!(agent_id, "opus-001");

    // Verify agent exists in team.db
    let entry = get_agent(&org_dir, &agent_id).unwrap().unwrap();
    assert_eq!(entry.display_name, "opus");
    assert_eq!(entry.org_id, "synapt-dev");

    // TODO: verify process columns (tmux_target, pid, status, log_path)
    // once the schema is extended. For now, this test passes because
    // the base registration works. The process columns are Sprint 9 work.
}

// ---------------------------------------------------------------------------
// Test 17: gr spawn down terminates tmux session
// ---------------------------------------------------------------------------

#[test]
#[should_panic(expected = "not yet implemented")]
fn test_spawn_down_kills_session() {
    // gr spawn down should:
    // 1. Send /exit to each agent window via send-keys
    // 2. Wait 2 seconds for graceful shutdown
    // 3. Kill the tmux session
    // 4. Update team.db status to "offline" for all agents
    let result = teardown_tmux_session("synapt");
    assert!(result.is_ok());
    // Verify: tmux has-session -t synapt returns non-zero
    unimplemented!("teardown_tmux_session not yet implemented")
}

// ---------------------------------------------------------------------------
// Test 18: gr spawn status reads from team.db + tmux
// ---------------------------------------------------------------------------

#[test]
#[should_panic(expected = "not yet implemented")]
fn test_spawn_status_reads_team_db() {
    // gr spawn status should read from team.db (registered agents + process info)
    // AND check tmux for actual pane liveness. If team.db says "online" but
    // tmux pane is dead, status should report "crashed".
    let status = get_spawn_status("synapt");
    assert!(!status.is_empty());
    // Each entry should have: agent_id, display_name, status, pid, tmux_target
    unimplemented!("get_spawn_status not yet implemented")
}

// ---------------------------------------------------------------------------
// Stub functions — will be implemented in grip#443
// ---------------------------------------------------------------------------

fn create_tmux_session(_session: &str) -> String {
    unimplemented!("create_tmux_session not yet implemented")
}

fn create_agent_windows(_session: &str, _agents: &[&str]) -> Vec<String> {
    unimplemented!("create_agent_windows not yet implemented")
}

fn setup_pipe_panes(
    _session: &str,
    _agents: &[&str],
    _log_dir: &std::path::Path,
) -> HashMap<String, PathBuf> {
    unimplemented!("setup_pipe_panes not yet implemented")
}

fn teardown_tmux_session(_session: &str) -> anyhow::Result<()> {
    unimplemented!("teardown_tmux_session not yet implemented")
}

fn get_spawn_status(_session: &str) -> Vec<HashMap<String, String>> {
    unimplemented!("get_spawn_status not yet implemented")
}