tftio-clanker 0.2.0

Launch AI harnesses with runtime-configured context, domains, models, and prompts
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

//! Runtime-configuration doctor integration.

use std::path::PathBuf;

use tftio_cli_common::{DoctorCheck, DoctorChecks, RepoInfo};

use crate::config::load_config;

/// Doctor checks bound to one runtime configuration path.
pub struct Doctor {
    config_path: Option<PathBuf>,
    current_dir: PathBuf,
    home: Option<PathBuf>,
}

impl Doctor {
    /// Create doctor checks for an optional resolved config path.
    #[must_use]
    pub const fn new(
        config_path: Option<PathBuf>,
        current_dir: PathBuf,
        home: Option<PathBuf>,
    ) -> Self {
        Self {
            config_path,
            current_dir,
            home,
        }
    }
}

impl DoctorChecks for Doctor {
    fn repo_info() -> RepoInfo {
        RepoInfo::new("tftio-stuff", "clanker")
    }

    fn current_version() -> &'static str {
        env!("CARGO_PKG_VERSION")
    }

    fn tool_checks(&self) -> Vec<DoctorCheck> {
        let mut checks = self.config_path.as_ref().map_or_else(
            || {
                vec![DoctorCheck::fail(
                    "Clanker config",
                    "$HOME is not set and CLANKER_CONFIG was not provided",
                )]
            },
            |path| match load_config(path) {
                Ok(loaded) => {
                    let mut checks = vec![DoctorCheck::pass(format!(
                        "Config file: {}",
                        loaded.base_path.display()
                    ))];
                    if let Some(overlay) = loaded.overlay_path {
                        checks.push(DoctorCheck::pass(format!(
                            "Local overlay: {}",
                            overlay.display()
                        )));
                    }
                    checks.push(DoctorCheck::pass("Runtime config schema and invariants"));
                    if let Some(home) = &self.home {
                        let filesystem_issues = loaded.config.filesystem_issues(home);
                        if filesystem_issues.is_empty() {
                            checks.push(DoctorCheck::pass("Skill bundle and configured skills"));
                        } else {
                            checks.extend(
                                filesystem_issues.into_iter().map(|issue| {
                                    DoctorCheck::fail("Skill bundle", issue.to_string())
                                }),
                            );
                        }
                    } else {
                        checks.push(DoctorCheck::fail(
                            "Skill bundle",
                            "$HOME is not set; cannot resolve defaults.skills_bundle",
                        ));
                    }
                    checks
                }
                Err(error) => vec![DoctorCheck::fail("Clanker config", error.to_string())],
            },
        );

        let legacy_context = self.current_dir.join(".context");
        if legacy_context.exists() {
            checks.push(DoctorCheck::fail(
                "Legacy context file",
                format!(
                    "{} exists; replace it with .clanker TOML",
                    legacy_context.display()
                ),
            ));
        } else {
            checks.push(DoctorCheck::pass("No legacy .context file in cwd"));
        }
        checks
    }
}