ito-common 0.1.33

Common utilities and error types for Ito
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

//! Harness session environment detection shared across Ito crates.

/// Ito harness identifiers inferred from session environment variables.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HarnessKind {
    /// Generic Ito harness session override.
    Generic,
    /// Claude Code harness.
    ClaudeCode,
    /// OpenCode harness.
    OpenCode,
    /// Codex harness.
    Codex,
    /// GitHub Copilot harness.
    GitHubCopilot,
    /// Pi coding agent harness.
    Pi,
}

impl HarnessKind {
    /// Return the canonical harness identifier used in generated Ito assets.
    pub fn canonical_name(self) -> &'static str {
        match self {
            Self::Generic => "generic",
            Self::ClaudeCode => "claude-code",
            Self::OpenCode => "opencode",
            Self::Codex => "codex",
            Self::GitHubCopilot => "github-copilot",
            Self::Pi => "pi",
        }
    }
}

/// Resolved harness session environment.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HarnessSessionEnv {
    /// Environment variable that supplied the session id.
    pub env_var: &'static str,
    /// Session id value from the environment.
    pub session_id: String,
    /// Harness kind inferred from the environment variable.
    pub harness: HarnessKind,
}

#[derive(Debug, Clone, Copy)]
struct HarnessSessionProbe {
    env_var: &'static str,
    harness: HarnessKind,
}

const HARNESS_SESSION_PROBES: &[HarnessSessionProbe] = &[
    HarnessSessionProbe {
        env_var: "ITO_HARNESS_SESSION_ID",
        harness: HarnessKind::Generic,
    },
    HarnessSessionProbe {
        env_var: "CLAUDE_SESSION_ID",
        harness: HarnessKind::ClaudeCode,
    },
    HarnessSessionProbe {
        env_var: "OPENCODE_SESSION_ID",
        harness: HarnessKind::OpenCode,
    },
    HarnessSessionProbe {
        env_var: "CODEX_SESSION_ID",
        harness: HarnessKind::Codex,
    },
    HarnessSessionProbe {
        env_var: "GITHUB_COPILOT_CHAT_SESSION_ID",
        harness: HarnessKind::GitHubCopilot,
    },
    HarnessSessionProbe {
        env_var: "PI_SESSION_ID",
        harness: HarnessKind::Pi,
    },
];

/// Environment variables that Ito checks for harness session context, in precedence order.
pub const HARNESS_SESSION_ENV_VARS: &[&str] = &[
    "ITO_HARNESS_SESSION_ID",
    "CLAUDE_SESSION_ID",
    "OPENCODE_SESSION_ID",
    "CODEX_SESSION_ID",
    "GITHUB_COPILOT_CHAT_SESSION_ID",
    "PI_SESSION_ID",
];

/// Resolve harness session environment from the current process.
pub fn resolve_harness_session_env() -> Option<HarnessSessionEnv> {
    resolve_harness_session_env_with(|env_var| std::env::var(env_var).ok())
}

fn resolve_harness_session_env_with(
    mut get_env: impl FnMut(&str) -> Option<String>,
) -> Option<HarnessSessionEnv> {
    for HarnessSessionProbe { env_var, harness } in HARNESS_SESSION_PROBES {
        let Some(session_id) = get_env(env_var) else {
            continue;
        };
        let session_id = session_id.trim();
        if session_id.is_empty() {
            continue;
        }
        let session_id = session_id.to_owned();
        return Some(HarnessSessionEnv {
            env_var,
            session_id,
            harness: *harness,
        });
    }

    None
}

/// Resolve the first configured harness session id from the current process.
pub fn resolve_harness_session_id() -> Option<String> {
    resolve_harness_session_env().map(|env| env.session_id)
}

/// Detect the current harness canonical name from session environment variables.
pub fn detect_harness_name() -> &'static str {
    resolve_harness_session_env()
        .map(|env| env.harness.canonical_name())
        .unwrap_or("unknown")
}

#[cfg(test)]
#[path = "harness_tests.rs"]
mod harness_tests;