eidos-ekf 0.1.0

EKF package contract support for Eidos.
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
135
136

use std::path::{Path, PathBuf};

use crate::model::*;

pub(crate) fn manifest_source_paths(manifest: &Manifest) -> Vec<(String, String, Vec<String>)> {
    let mut out = Vec::new();
    out.extend(
        manifest
            .sources
            .docs
            .iter()
            .cloned()
            .map(|p| ("docs".into(), p, Vec::new())),
    );
    out.extend(
        manifest
            .sources
            .skills
            .iter()
            .cloned()
            .map(|p| ("skills".into(), p, Vec::new())),
    );
    out.extend(
        manifest
            .sources
            .agents
            .iter()
            .cloned()
            .map(|p| ("agents".into(), p, Vec::new())),
    );
    out.extend(
        manifest
            .sources
            .capabilities
            .iter()
            .cloned()
            .map(|p| ("capabilities".into(), p, Vec::new())),
    );
    out.extend(
        manifest
            .sources
            .brief_profiles
            .iter()
            .cloned()
            .map(|p| ("brief_profiles".into(), p, Vec::new())),
    );
    out.extend(
        manifest
            .sources
            .workflows
            .iter()
            .cloned()
            .map(|p| ("workflows".into(), p, Vec::new())),
    );
    out.extend(
        manifest
            .sources
            .evals
            .iter()
            .cloned()
            .map(|p| ("evals".into(), p, Vec::new())),
    );
    out.extend(
        manifest
            .sources
            .code
            .iter()
            .map(|c| ("code".into(), c.path.clone(), c.languages.clone())),
    );
    out
}

pub(crate) fn parse_inline_list(value: &str) -> Vec<String> {
    let value = value.trim();
    if !(value.starts_with('[') && value.ends_with(']')) {
        return if value.is_empty() {
            Vec::new()
        } else {
            vec![unquote(value).to_string()]
        };
    }
    value[1..value.len() - 1]
        .split(',')
        .map(str::trim)
        .filter(|item| !item.is_empty())
        .map(unquote)
        .map(str::to_string)
        .collect()
}

pub(crate) fn unquote(s: &str) -> &str {
    let s = s.trim();
    s.strip_prefix('"')
        .and_then(|s| s.strip_suffix('"'))
        .or_else(|| s.strip_prefix('\'').and_then(|s| s.strip_suffix('\'')))
        .unwrap_or(s)
}

pub(crate) fn set_source_list(sources: &mut SourceManifest, key: &str, values: Vec<String>) {
    match key {
        "docs" => sources.docs = values,
        "skills" => sources.skills = values,
        "agents" => sources.agents = values,
        "capabilities" => sources.capabilities = values,
        "brief_profiles" => sources.brief_profiles = values,
        "workflows" => sources.workflows = values,
        "evals" => sources.evals = values,
        _ => {}
    }
}

pub(crate) fn unknown_field(line_no: usize, field: &str) -> EkfDiagnostic {
    EkfDiagnostic {
        severity: DiagnosticSeverity::Warning,
        kind: "unknown_field".into(),
        message: format!("unknown EKF field '{field}'"),
        source: Some(format!("line {line_no}")),
    }
}

pub(crate) fn malformed(line_no: usize, detail: &str) -> EkfDiagnostic {
    EkfDiagnostic {
        severity: DiagnosticSeverity::Warning,
        kind: "malformed_line".into(),
        message: format!("could not parse EKF manifest: {detail}"),
        source: Some(format!("line {line_no}")),
    }
}

pub(crate) fn resolve_path(root: &Path, path: &Path) -> PathBuf {
    if path.is_absolute() {
        path.to_path_buf()
    } else {
        root.join(path)
    }
}