wsx-core 0.23.0

Composable project, Git worktree, terminal runtime, hook, and model primitives for wsx.
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

use super::{paths, IntegrationTarget};
use std::path::Path;

fn commands(target: IntegrationTarget) -> &'static [&'static str] {
    match target {
        IntegrationTarget::Pi => &["pi"],
        IntegrationTarget::Omp => &["omp"],
        IntegrationTarget::Claude => &["claude"],
        IntegrationTarget::Codex => &["codex"],
        IntegrationTarget::Copilot => &["copilot"],
        IntegrationTarget::Devin => &["devin"],
        IntegrationTarget::Droid => &["droid"],
        IntegrationTarget::Kimi => &["kimi"],
        IntegrationTarget::Opencode => &["opencode"],
        IntegrationTarget::Kilo => &["kilo", "kilo-code"],
        IntegrationTarget::Hermes => &["hermes"],
        IntegrationTarget::Qodercli => &["qoder", "qodercli"],
        IntegrationTarget::Qwen => &["qwen"],
        IntegrationTarget::Cursor => &["agent", "cursor-agent"],
        IntegrationTarget::Mastracode => &["mastracode"],
        IntegrationTarget::AntigravityCli => &["agy"],
        IntegrationTarget::Grok => &["grok"],
    }
}

#[cfg(unix)]
fn executable(path: &Path) -> bool {
    use std::os::unix::fs::PermissionsExt;
    path.metadata()
        .is_ok_and(|m| m.is_file() && m.permissions().mode() & 0o111 != 0)
}
#[cfg(not(unix))]
fn executable(path: &Path) -> bool {
    path.is_file()
}

fn command_on_path(
    target: IntegrationTarget,
    path: Option<std::ffi::OsString>,
) -> Option<std::path::PathBuf> {
    path.as_deref()
        .into_iter()
        .flat_map(std::env::split_paths)
        .find_map(|dir| {
            commands(target)
                .iter()
                .map(|command| dir.join(command))
                .find(|path| executable(path))
        })
}

pub(crate) fn command_path(target: IntegrationTarget) -> Option<std::path::PathBuf> {
    if let Some(path) = command_on_path(target, std::env::var_os("PATH")) {
        return Some(path);
    }
    match target {
        IntegrationTarget::Codex => paths::root(target).ok().and_then(|root| {
            glob::glob(&format!(
                "{}/packages/standalone/releases/*/bin/codex",
                root.display()
            ))
            .ok()?
            .filter_map(Result::ok)
            .find(|path| executable(path))
        }),
        IntegrationTarget::Hermes if cfg!(windows) => paths::root(target).ok().and_then(|root| {
            [
                root.join("hermes.exe"),
                root.join("bin/hermes.exe"),
                root.join("Scripts/hermes.exe"),
            ]
            .into_iter()
            .find(|path| executable(path))
        }),
        _ => None,
    }
}

pub fn is_available(target: IntegrationTarget) -> bool {
    command_path(target).is_some()
}

#[cfg(test)]
pub(crate) fn available_on_path_for_test(target: IntegrationTarget, path: &Path) -> bool {
    command_on_path(target, Some(path.as_os_str().to_owned())).is_some()
}