claudectl 0.35.0

Auto-pilot for Claude Code — a local model watches every session and decides what to approve
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

#![allow(dead_code)]

use super::adapter::*;
use crate::discovery;

/// Claude Code adapter -- wraps existing claudectl discovery, monitoring, and terminal integration.
pub struct ClaudeCodeAdapter;

impl AgentAdapter for ClaudeCodeAdapter {
    fn family(&self) -> AgentFamily {
        AgentFamily::ClaudeCode
    }

    fn capabilities(&self) -> AdapterCapabilities {
        AdapterCapabilities {
            discover_sessions: true,
            monitor_state: true,
            send_input: true,
            deliver_interrupt: true,
            request_checkpoint: false,
            request_compaction: false,
            pause: true,
            resume: true,
            terminate: true,
        }
    }

    fn discover_sessions(&self) -> Vec<AgentIdentity> {
        let sessions = discovery::scan_sessions();
        sessions
            .into_iter()
            .map(|s| AgentIdentity {
                agent_family: "claude-code".into(),
                session_id: s.session_id,
                cwd: s.cwd,
                branch: None, // Resolved later by resolve_worktree_ids
                pid: Some(s.pid),
            })
            .collect()
    }

    fn get_state(&self, session_id: &str) -> Option<AgentState> {
        let sessions = discovery::scan_sessions();
        let session = sessions.iter().find(|s| s.session_id == session_id)?;

        let context_pressure = if session.context_max > 0 {
            Some(session.context_tokens as f64 / session.context_max as f64)
        } else {
            None
        };

        Some(AgentState {
            status: session.status.to_string(),
            context_pressure,
            pending_tool: session.pending_tool_name.clone(),
            last_output: None,
            cost_usd: Some(session.cost_usd),
        })
    }

    fn send_input(&self, session_id: &str, text: &str) -> Result<(), String> {
        let sessions = discovery::scan_sessions();
        let session = sessions
            .iter()
            .find(|s| s.session_id == session_id)
            .ok_or_else(|| format!("Session not found: {session_id}"))?;
        crate::terminals::send_input(session, text)
    }

    fn pause(&self, session_id: &str) -> Result<(), String> {
        // Send a compact/pause instruction to the session
        self.send_input(session_id, "/compact")
    }

    fn resume(&self, session_id: &str) -> Result<(), String> {
        // Claude Code sessions resume automatically when given input
        self.send_input(session_id, "continue")
    }

    fn terminate(&self, session_id: &str) -> Result<(), String> {
        let sessions = discovery::scan_sessions();
        let session = sessions
            .iter()
            .find(|s| s.session_id == session_id)
            .ok_or_else(|| format!("Session not found: {session_id}"))?;

        let pid = session.pid;
        let output = std::process::Command::new("kill")
            .arg(pid.to_string())
            .output()
            .map_err(|e| format!("kill failed: {e}"))?;

        if output.status.success() {
            Ok(())
        } else {
            Err(format!("kill returned: {}", output.status))
        }
    }
}

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

    #[test]
    fn claude_adapter_family() {
        let adapter = ClaudeCodeAdapter;
        assert_eq!(adapter.family(), AgentFamily::ClaudeCode);
    }

    #[test]
    fn claude_adapter_capabilities() {
        let adapter = ClaudeCodeAdapter;
        let caps = adapter.capabilities();
        assert!(caps.discover_sessions);
        assert!(caps.monitor_state);
        assert!(caps.send_input);
        assert!(caps.deliver_interrupt);
        assert!(caps.terminate);
        assert!(!caps.request_checkpoint);
        assert!(!caps.request_compaction);
    }

    #[test]
    fn claude_adapter_discover_returns_vec() {
        let adapter = ClaudeCodeAdapter;
        // Should not panic, even if no sessions exist
        let sessions = adapter.discover_sessions();
        for s in &sessions {
            assert_eq!(s.agent_family, "claude-code");
            assert!(s.pid.is_some());
        }
    }
}