zig-core 0.10.0

Core library for zig — workflow orchestration engine for AI coding agents
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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use super::*;

#[test]
fn pack_creates_valid_zip() {
    let tmp = tempfile::TempDir::new().unwrap();
    let workflow_dir = tmp.path().join("my-workflow");
    std::fs::create_dir(&workflow_dir).unwrap();

    // Create a workflow TOML
    std::fs::write(
        workflow_dir.join("workflow.toml"),
        r#"[workflow]
name = "test-pack"

[[step]]
name = "hello"
prompt = "Say hello"
"#,
    )
    .unwrap();

    // Create a prompt file
    let prompts_dir = workflow_dir.join("prompts");
    std::fs::create_dir(&prompts_dir).unwrap();
    std::fs::write(prompts_dir.join("greeting.md"), "You are a greeter.").unwrap();

    let output_path = tmp.path().join("output.zwfz");
    let result = pack(
        workflow_dir.to_str().unwrap(),
        Some(output_path.to_str().unwrap()),
    );
    assert!(result.is_ok());

    let output = result.unwrap();
    assert!(output.exists());

    // Verify the zip can be parsed back
    let (wf, _source) = parser::parse_workflow(&output).unwrap();
    assert_eq!(wf.workflow.name, "test-pack");
}

#[test]
fn pack_default_output_name() {
    let tmp = tempfile::TempDir::new().unwrap();
    let workflow_dir = tmp.path().join("healthcare");
    std::fs::create_dir(&workflow_dir).unwrap();

    std::fs::write(
        workflow_dir.join("healthcare.toml"),
        r#"[workflow]
name = "Hospital Triage"

[[step]]
name = "triage"
prompt = "Triage"
"#,
    )
    .unwrap();

    // Change to tmp dir so output goes there
    let original_dir = std::env::current_dir().unwrap();
    std::env::set_current_dir(tmp.path()).unwrap();

    let result = pack(workflow_dir.to_str().unwrap(), None);
    std::env::set_current_dir(original_dir).unwrap();

    assert!(result.is_ok());
    let output = result.unwrap();
    assert_eq!(output.file_name().unwrap(), "hospital-triage.zwfz");
}

#[test]
fn pack_not_a_directory() {
    let tmp = tempfile::TempDir::new().unwrap();
    let file_path = tmp.path().join("not-a-dir.txt");
    std::fs::write(&file_path, "not a directory").unwrap();

    let result = pack(file_path.to_str().unwrap(), None);
    assert!(result.is_err());
    assert!(result.unwrap_err().to_string().contains("not a directory"));
}

#[test]
fn pack_no_workflow_file() {
    let tmp = tempfile::TempDir::new().unwrap();
    let workflow_dir = tmp.path().join("empty");
    std::fs::create_dir(&workflow_dir).unwrap();

    std::fs::write(workflow_dir.join("readme.md"), "No workflow here").unwrap();

    let result = pack(workflow_dir.to_str().unwrap(), None);
    assert!(result.is_err());
    assert!(
        result
            .unwrap_err()
            .to_string()
            .contains("no workflow TOML file")
    );
}

#[test]
fn pack_round_trip_with_role_files() {
    let tmp = tempfile::TempDir::new().unwrap();
    let workflow_dir = tmp.path().join("roles-workflow");
    std::fs::create_dir(&workflow_dir).unwrap();

    let prompts_dir = workflow_dir.join("prompts");
    std::fs::create_dir(&prompts_dir).unwrap();

    std::fs::write(
        workflow_dir.join("workflow.toml"),
        r#"[workflow]
name = "roles-pack"

[roles.doctor]
system_prompt_file = "prompts/doctor.md"

[vars.symptoms]
type = "string"
from = "prompt"

[[step]]
name = "examine"
prompt = "Examine: ${symptoms}"
role = "doctor"
"#,
    )
    .unwrap();
    std::fs::write(
        prompts_dir.join("doctor.md"),
        "You are a board-certified physician.",
    )
    .unwrap();

    let output_path = tmp.path().join("roles-pack.zwfz");
    pack(
        workflow_dir.to_str().unwrap(),
        Some(output_path.to_str().unwrap()),
    )
    .unwrap();

    // Parse the zip and verify role prompt file is accessible
    let (wf, source) = parser::parse_workflow(&output_path).unwrap();
    assert_eq!(wf.roles.len(), 1);
    assert_eq!(
        wf.roles["doctor"].system_prompt_file.as_deref(),
        Some("prompts/doctor.md")
    );

    let prompt_content = std::fs::read_to_string(source.dir().join("prompts/doctor.md")).unwrap();
    assert_eq!(prompt_content, "You are a board-certified physician.");
}