atm-core 0.2.3

Core domain types for ATM - Claude Code agent management
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

//! Beads task lookup for preview pane integration.
//!
//! Scans `.beads/issues.jsonl` in a working directory for in-progress tasks.

use std::path::Path;

/// A beads task summary for display in the preview pane.
#[derive(Debug, Clone)]
pub struct BeadsTask {
    /// Issue ID (e.g., "agent-tmux-manager-6n0")
    pub id: String,
    /// Issue title
    pub title: String,
    /// Issue description
    pub description: Option<String>,
}

/// Finds in-progress beads tasks in the given working directory.
///
/// Scans `{working_dir}/.beads/issues.jsonl` for entries with `"status":"in_progress"`.
/// Returns tasks sorted by most recently updated first.
pub fn find_in_progress_tasks(working_dir: &str) -> Vec<BeadsTask> {
    let jsonl_path = Path::new(working_dir).join(".beads/issues.jsonl");
    let content = match std::fs::read_to_string(&jsonl_path) {
        Ok(c) => c,
        Err(_) => return Vec::new(),
    };

    let mut tasks: Vec<(String, BeadsTask)> = Vec::new(); // (updated_at, task) for sorting

    for line in content.lines() {
        // Quick pre-filter before parsing JSON
        if !line.contains("\"in_progress\"") {
            continue;
        }
        if let Ok(val) = serde_json::from_str::<serde_json::Value>(line) {
            let status = val
                .get("status")
                .and_then(|v| v.as_str())
                .unwrap_or_default();
            if status != "in_progress" {
                continue;
            }
            let id = val
                .get("id")
                .and_then(|v| v.as_str())
                .unwrap_or_default()
                .to_string();
            let title = val
                .get("title")
                .and_then(|v| v.as_str())
                .unwrap_or_default()
                .to_string();
            let updated_at = val
                .get("updated_at")
                .and_then(|v| v.as_str())
                .unwrap_or_default()
                .to_string();

            let description = val
                .get("description")
                .and_then(|v| v.as_str())
                .filter(|s| !s.is_empty())
                .map(|s| s.to_string());

            if !id.is_empty() && !title.is_empty() {
                tasks.push((
                    updated_at,
                    BeadsTask {
                        id,
                        title,
                        description,
                    },
                ));
            }
        }
    }

    // Most recently updated first
    tasks.sort_by(|a, b| b.0.cmp(&a.0));
    tasks.into_iter().map(|(_, task)| task).collect()
}

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

    #[test]
    fn test_find_in_progress_tasks_empty() {
        let dir = tempfile::tempdir().unwrap();
        let result = find_in_progress_tasks(dir.path().to_str().unwrap());
        assert!(result.is_empty());
    }

    #[test]
    fn test_find_in_progress_tasks() {
        let dir = tempfile::tempdir().unwrap();
        let beads_dir = dir.path().join(".beads");
        fs::create_dir_all(&beads_dir).unwrap();
        fs::write(
            beads_dir.join("issues.jsonl"),
            r#"{"id":"test-1","title":"Open task","status":"open","updated_at":"2026-01-01T00:00:00Z"}
{"id":"test-2","title":"Active task","status":"in_progress","updated_at":"2026-01-02T00:00:00Z"}
{"id":"test-3","title":"Done task","status":"closed","updated_at":"2026-01-03T00:00:00Z"}
{"id":"test-4","title":"Another active","status":"in_progress","updated_at":"2026-01-04T00:00:00Z"}
"#,
        )
        .unwrap();

        let result = find_in_progress_tasks(dir.path().to_str().unwrap());
        assert_eq!(result.len(), 2);
        assert_eq!(result[0].title, "Another active"); // most recent first
        assert_eq!(result[1].title, "Active task");
    }
}