dkp 0.4.3

dkp — Domain Knowledge Pack management CLI
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

use axum::{extract::State, response::Json};
use serde::Serialize;
use std::sync::Arc;

use crate::cmd::webui::server::AppState;

#[derive(Serialize)]
pub struct PackSummary {
    pub name: String,
    pub version: String,
    pub domain: String,
    pub update_date: String,
    pub description: Option<String>,
    pub counts: AssetCounts,
}

#[derive(Serialize)]
pub struct AssetCounts {
    pub glossary: usize,
    pub rules: usize,
    pub chunks: usize,
    pub eval_cases: usize,
    pub has_graph: bool,
    pub has_skills: bool,
    pub has_l10n: bool,
    pub has_mcp_manifest: bool,
    pub has_cross_refs: bool,
    pub has_ontology: bool,
    pub has_constraints: bool,
    pub has_system_prompt: bool,
}

pub async fn get_pack(State(state): State<Arc<AppState>>) -> Json<PackSummary> {
    let pack = &state.pack;
    let m = &pack.manifest;

    let glossary = pack
        .load_glossary()
        .ok()
        .flatten()
        .map(|g| g.terms.len())
        .unwrap_or(0);
    let rules = pack
        .load_rules()
        .ok()
        .flatten()
        .map(|r| r.rules.len())
        .unwrap_or(0);
    let chunks = pack.load_chunks().ok().map(|c| c.len()).unwrap_or(0);
    let eval_cases = pack.load_eval_set().ok().map(|e| e.len()).unwrap_or(0);

    Json(PackSummary {
        name: m.name.clone(),
        version: m.version.clone(),
        domain: m.domain.clone(),
        update_date: m.update_date.clone(),
        description: m.description.clone(),
        counts: AssetCounts {
            glossary,
            rules,
            chunks,
            eval_cases,
            has_graph: pack.has_knowledge_graph(),
            has_skills: pack.has_skills(),
            has_l10n: pack.has_l10n(),
            has_mcp_manifest: pack.has_mcp_manifest(),
            has_cross_refs: pack.has_cross_refs(),
            has_ontology: pack.machine_dir().join("ontology.json").exists(),
            has_constraints: pack.machine_dir().join("constraints.json").exists(),
            has_system_prompt: pack.machine_dir().join("system_prompt.md").exists(),
        },
    })
}