meld 1.1.5

Deterministic filesystem state management using Merkle trees
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

//! Prompt link contract for generation lineage payload.

use crate::error::ApiError;
use crate::prompt_context::contracts::PromptContextLineageContract;
use serde::{Deserialize, Serialize};

const PROMPT_LINK_PREFIX_BYTES: usize = 16;

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct PromptLinkContractV1 {
    pub prompt_link_id: String,
    pub prompt_digest: String,
    pub context_digest: String,
    pub system_prompt_artifact_id: String,
    pub user_prompt_template_artifact_id: String,
    pub rendered_prompt_artifact_id: String,
    pub context_artifact_id: String,
}

impl PromptLinkContractV1 {
    pub fn from_lineage(lineage: &PromptContextLineageContract) -> Self {
        Self {
            prompt_link_id: lineage.prompt_link_id.clone(),
            prompt_digest: lineage.prompt_digest.clone(),
            context_digest: lineage.context_digest.clone(),
            system_prompt_artifact_id: lineage.system_prompt.artifact_id.clone(),
            user_prompt_template_artifact_id: lineage.user_prompt_template.artifact_id.clone(),
            rendered_prompt_artifact_id: lineage.rendered_prompt.artifact_id.clone(),
            context_artifact_id: lineage.context_payload.artifact_id.clone(),
        }
    }

    pub fn validate(&self) -> Result<(), ApiError> {
        if !self.prompt_link_id.starts_with("prompt-link-") {
            return Err(ApiError::PromptLinkContractInvalid {
                reason: "prompt_link_id must start with prompt-link-".to_string(),
            });
        }

        for (name, value) in [
            ("prompt_digest", self.prompt_digest.as_str()),
            ("context_digest", self.context_digest.as_str()),
            (
                "system_prompt_artifact_id",
                self.system_prompt_artifact_id.as_str(),
            ),
            (
                "user_prompt_template_artifact_id",
                self.user_prompt_template_artifact_id.as_str(),
            ),
            (
                "rendered_prompt_artifact_id",
                self.rendered_prompt_artifact_id.as_str(),
            ),
            ("context_artifact_id", self.context_artifact_id.as_str()),
        ] {
            if !is_blake3_hex(value) {
                return Err(ApiError::PromptLinkContractInvalid {
                    reason: format!("{} must be 64 char lowercase hex", name),
                });
            }
        }

        Ok(())
    }
}

pub fn build_prompt_link_id(prompt_digest: &str) -> String {
    let prompt_link_suffix_len = PROMPT_LINK_PREFIX_BYTES.min(prompt_digest.len());
    format!("prompt-link-{}", &prompt_digest[..prompt_link_suffix_len])
}

fn is_blake3_hex(value: &str) -> bool {
    value.len() == 64
        && value
            .as_bytes()
            .iter()
            .all(|byte| matches!(byte, b'0'..=b'9' | b'a'..=b'f'))
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::prompt_context::contracts::{PromptContextArtifactKind, PromptContextArtifactRef};

    #[test]
    fn validates_contract() {
        let digest = "a".repeat(64);
        let contract = PromptLinkContractV1 {
            prompt_link_id: build_prompt_link_id(&digest),
            prompt_digest: digest.clone(),
            context_digest: digest.clone(),
            system_prompt_artifact_id: digest.clone(),
            user_prompt_template_artifact_id: digest.clone(),
            rendered_prompt_artifact_id: digest.clone(),
            context_artifact_id: digest,
        };
        contract.validate().unwrap();
    }

    #[test]
    fn from_lineage_maps_ids_and_digests() {
        let digest = "b".repeat(64);
        let lineage = PromptContextLineageContract {
            prompt_link_id: "prompt-link-bbbbbbbbbbbbbbbb".to_string(),
            prompt_digest: digest.clone(),
            context_digest: digest.clone(),
            system_prompt: PromptContextArtifactRef {
                artifact_id: digest.clone(),
                digest: digest.clone(),
                byte_len: 1,
                kind: PromptContextArtifactKind::SystemPrompt,
            },
            user_prompt_template: PromptContextArtifactRef {
                artifact_id: digest.clone(),
                digest: digest.clone(),
                byte_len: 1,
                kind: PromptContextArtifactKind::UserPromptTemplate,
            },
            rendered_prompt: PromptContextArtifactRef {
                artifact_id: digest.clone(),
                digest: digest.clone(),
                byte_len: 1,
                kind: PromptContextArtifactKind::RenderedPrompt,
            },
            context_payload: PromptContextArtifactRef {
                artifact_id: digest.clone(),
                digest: digest.clone(),
                byte_len: 1,
                kind: PromptContextArtifactKind::ContextPayload,
            },
        };

        let contract = PromptLinkContractV1::from_lineage(&lineage);
        assert_eq!(contract.prompt_digest, lineage.prompt_digest);
        assert_eq!(contract.context_digest, lineage.context_digest);
        assert_eq!(
            contract.context_artifact_id,
            lineage.context_payload.artifact_id
        );
    }
}