dkp 0.1.0

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

use anyhow::Result;
use clap::Args;
use std::path::PathBuf;

use dkp_core::{
    procedures::scaffold::{self, scaffold_script},
    Pack,
};

use crate::cli::CmdCtx;

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

    /// Procedure ID — used as the file stem and Rust crate name (e.g. "macro-calc")
    pub id: String,

    /// Human-readable title for the procedure
    #[arg(long, default_value = "")]
    pub title: String,

    /// One-sentence description of what the procedure does
    #[arg(long, default_value = "")]
    pub description: String,

    /// Procedure language/runtime: wasm | python | javascript
    #[arg(long, default_value = "wasm", value_name = "LANG")]
    pub lang: String,
}

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

    let title = if args.title.is_empty() {
        args.id
            .replace('-', " ")
            .split_whitespace()
            .map(|w| {
                let mut c = w.chars();
                match c.next() {
                    None => String::new(),
                    Some(f) => f.to_uppercase().to_string() + c.as_str(),
                }
            })
            .collect::<Vec<_>>()
            .join(" ")
    } else {
        args.title.clone()
    };

    let description = if args.description.is_empty() {
        format!("Executable procedure: {title}")
    } else {
        args.description.clone()
    };

    let (created, next_steps) = match args.lang.as_str() {
        "python" | "javascript" => {
            let files = scaffold_script(&pack.root, &args.id, &title, &description, &args.lang)?;
            let ext = if args.lang == "javascript" {
                "js"
            } else {
                "py"
            };
            let steps = format!(
                "Next steps:\n\
                 1. Edit machine/procedures/{id}.schema.json to describe your input/output shapes\n\
                 2. Implement logic in machine/procedures/{id}.{ext}\n\
                 3. Run `dkp run {pack} {id} --allow-unsigned` to test locally\n\
                 4. Run `dkp procedures validate {pack}` to check completeness",
                id = args.id,
                ext = ext,
                pack = args.pack.display(),
            );
            (files, steps)
        }
        _ => {
            let files = scaffold::scaffold(&pack.root, &args.id, &title, &description)?;
            let steps = format!(
                "Next steps:\n\
                 1. Edit machine/procedures/{id}.schema.json to describe your input/output shapes\n\
                 2. Implement logic in machine/procedures/src/{id}/src/main.rs\n\
                 3. Run machine/procedures/src/build.sh to compile all procedures\n\
                 4. Run `dkp procedures validate {pack}` to check completeness",
                id = args.id,
                pack = args.pack.display(),
            );
            (files, steps)
        }
    };

    println!("Scaffolded procedure '{}' (lang: {}):", args.id, args.lang);
    for path in &created {
        println!(
            "  {}",
            path.strip_prefix(&pack.root).unwrap_or(path).display()
        );
    }
    println!();
    println!("{next_steps}");

    Ok(())
}