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
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

use anyhow::Result;
use clap::{Args, Subcommand};
use std::collections::HashSet;
use std::path::PathBuf;

use comfy_table::{Table, presets::UTF8_FULL};
use dkp_core::{Pack, types::cross_refs::CrossRefsFile};

use crate::cli::CmdCtx;

#[derive(Args, Debug)]
pub struct CrossRefsArgs {
    /// Path to the DKP bundle directory
    pub pack: PathBuf,

    #[command(subcommand)]
    pub command: CrossRefsCommands,
}

#[derive(Subcommand, Debug)]
pub enum CrossRefsCommands {
    /// List all declared pack dependencies
    List,
    /// Check local_id values resolve to concepts in this bundle (Gate 4)
    Validate,
}

pub async fn run(args: CrossRefsArgs, _cli: &CmdCtx) -> Result<()> {
    let pack = Pack::open(&args.pack)?;

    if !pack.has_cross_refs() {
        println!("cross_refs.json not present in this pack.");
        return Ok(());
    }

    let bytes = std::fs::read(pack.machine_file("cross_refs.json"))?;
    let cross_refs_file: CrossRefsFile = serde_json::from_slice(&bytes)?;
    let refs = &cross_refs_file.cross_refs;

    match args.command {
        CrossRefsCommands::List => {
            let mut table = Table::new();
            table.load_preset(UTF8_FULL);
            table.set_header([
                "Local ID",
                "Remote Pack",
                "Version",
                "Remote ID",
                "Relation",
            ]);
            for r in refs {
                table.add_row([
                    &r.local_id,
                    &r.pack_name,
                    &r.pack_version,
                    &r.remote_id,
                    &r.relation,
                ]);
            }
            println!("{table}");
            println!("\n{} cross-reference(s)", refs.len());
        }

        CrossRefsCommands::Validate => {
            let declared_deps: HashSet<&str> = pack
                .manifest
                .dependencies
                .iter()
                .map(|d| d.name.as_str())
                .collect();

            let mut errors: Vec<String> = Vec::new();

            for r in refs {
                if !declared_deps.contains(r.pack_name.as_str()) {
                    errors.push(format!(
                        "{}: remote_pack '{}' not listed in manifest.dependencies",
                        r.local_id, r.pack_name
                    ));
                }
            }

            // Collect all known local concept IDs from machine-layer assets
            let mut known_ids: HashSet<String> = HashSet::new();
            if let Ok(Some(gf)) = pack.load_glossary() {
                known_ids.extend(gf.terms.iter().map(|t| t.id.clone()));
            }
            if let Ok(Some(rf)) = pack.load_rules() {
                known_ids.extend(rf.rules.iter().map(|r| r.id.clone()));
            }
            if let Ok(Some(cf)) = pack.load_constraints() {
                for c in cf.all_constraints() {
                    known_ids.insert(c.id.clone());
                }
            }
            if let Ok(Some(of)) = pack.load_ontology() {
                known_ids.extend(of.entity_types.iter().map(|e| e.id.clone()));
            }
            if let Ok(chunks) = pack.load_chunks() {
                known_ids.extend(chunks.iter().map(|c| c.id.clone()));
            }

            for r in refs {
                if !known_ids.contains(&r.local_id) {
                    errors.push(format!(
                        "local_id '{}' does not resolve to any concept in this bundle",
                        r.local_id
                    ));
                }
            }

            if errors.is_empty() {
                println!(
                    "[PASS] cross_refs — {} ref(s), all local_ids resolve, all remote_packs declared",
                    refs.len()
                );
            } else {
                println!("[FAIL] cross_refs — {} error(s):", errors.len());
                for e in &errors {
                    println!("  {e}");
                }
                anyhow::bail!("cross_refs validation failed");
            }
        }
    }

    Ok(())
}