agentic-outer-dag-bin 0.1.1

External outer-DAG driver for worktree→PR→CodeRabbit loops
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

use crate::state::RunState;
use anyhow::Result;
use linear_tools::LinearTools;
use sha2::Digest;
use sha2::Sha256;

pub async fn post_handoff_once(state: &mut RunState, message: &str) -> Result<()> {
    if !state.settings.linear_handoff_enabled {
        return Ok(());
    }

    post_handoff_once_unchecked(state, message).await
}

pub async fn post_handoff_once_forced(state: &mut RunState, message: &str) -> Result<()> {
    post_handoff_once_unchecked(state, message).await
}

async fn post_handoff_once_unchecked(state: &mut RunState, message: &str) -> Result<()> {
    let digest = handoff_digest(message);
    if should_skip_handoff(state, &digest) {
        return Ok(());
    }

    let tools = LinearTools::new();
    tools
        .add_comment(state.ticket.linear_key.clone(), message.to_string(), None)
        .await?;
    state.handoff.linear_comment_posted = true;
    state.handoff.linear_comment_body_sha256 = Some(digest);
    state.handoff.posted_at = Some(chrono::Utc::now().to_rfc3339());
    Ok(())
}

fn handoff_digest(message: &str) -> String {
    format!("{:x}", Sha256::digest(message.as_bytes()))
}

fn should_skip_handoff(state: &RunState, digest: &str) -> bool {
    state.handoff.linear_comment_posted
        && state.handoff.linear_comment_body_sha256.as_deref() == Some(digest)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn handoff_skips_when_same_digest_was_already_posted() {
        let digest = handoff_digest("same");
        let mut state = crate::state::RunState::for_start(
            "ENG-992",
            &crate::worktree::TargetWorktree {
                path: std::env::current_dir().unwrap(),
                branch: "feature/eng-992".to_string(),
                base_ref: "origin/main".to_string(),
            },
            true,
        )
        .unwrap();
        state.handoff.linear_comment_posted = true;
        state.handoff.linear_comment_body_sha256 = Some(digest.clone());

        assert!(should_skip_handoff(&state, &digest));
        assert!(!should_skip_handoff(&state, &handoff_digest("different")));
    }

    #[tokio::test]
    async fn handoff_is_suppressed_when_disabled_in_settings() {
        let mut state = crate::state::RunState::for_start(
            "ENG-992",
            &crate::worktree::TargetWorktree {
                path: std::env::current_dir().unwrap(),
                branch: "feature/eng-992".to_string(),
                base_ref: "origin/main".to_string(),
            },
            true,
        )
        .unwrap();
        state.settings.linear_handoff_enabled = false;

        post_handoff_once(&mut state, "suppressed during safety test")
            .await
            .unwrap();

        assert!(!state.handoff.linear_comment_posted);
        assert!(state.handoff.linear_comment_body_sha256.is_none());
        assert!(state.handoff.posted_at.is_none());
    }
}