contract.rs

// SPDX-License-Identifier: PMPL-1.0-or-later
// Copyright (c) 2026 Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>
//
// K9 contract generator for k9iser — produces .k9 contract files from
// parsed config structures and manifest rules. Also builds in-memory
// K9Contract structs for use by the validator.

use crate::abi::{
    ConfigFormat, IntendDeclaration, K9Contract, MustRule, SafetyTier, parse_dust_rule,
    parse_must_rule, parse_trust_source,
};
use crate::codegen::parser::{ParsedEntry, ValueType};

/// Generate a .k9 contract file as a string from manifest rules and parsed config entries.
///
/// The output format:
/// ```text
/// K9!
/// # SPDX-License-Identifier: PMPL-1.0-or-later
/// # Auto-generated K9 contract for <name>
/// # Safety tier: <tier>
///
/// pedigree = {
///   schema_version = "1.0.0"
///   metadata = { name = "<name>" version = "1.0.0" }
///   security = { leash = "<tier>" signature_required = false }
/// }
///
/// [must]
/// key : type { constraint, ... }
///
/// [trust]
/// trust-type = "source"
///
/// [dust]
/// action = ["target"]
///
/// [intend]
/// label = true
/// ```
pub fn generate_k9_contract(
    name: &str,
    safety_tier: SafetyTier,
    must_rules: &[String],
    trust_sources: &[String],
    dust_rules: &[String],
    intend_declarations: &[String],
    parsed_entries: &[ParsedEntry],
) -> String {
    let mut output = String::new();

    // Header — `K9!` MUST be the first non-empty line and a `pedigree`
    // block is mandatory, per the canonical hyperpolymath/k9-validate-action.
    output.push_str("K9!\n");
    output.push_str("# SPDX-License-Identifier: PMPL-1.0-or-later\n");
    output.push_str(&format!("# Auto-generated K9 contract for {}\n", name));
    output.push_str(&format!("# Safety tier: {}\n", safety_tier));
    output.push('\n');

    // [pedigree] — provenance + security leash. Required fields:
    //   metadata.name (error if absent), version/schema_version (warning),
    //   security.leash ∈ {kennel,yard,hunt} (warning if absent), and a
    //   signature field (error at hunt level if absent).
    output.push_str("pedigree = {\n");
    output.push_str("  schema_version = \"1.0.0\"\n");
    output.push_str("  metadata = {\n");
    output.push_str(&format!("    name = \"{}\"\n", name));
    output.push_str("    version = \"1.0.0\"\n");
    output.push_str("  }\n");
    output.push_str("  security = {\n");
    output.push_str(&format!("    leash = \"{}\"\n", safety_tier));
    output.push_str("    signature_required = false\n");
    output.push_str("  }\n");
    output.push_str("}\n");
    output.push('\n');

    // [must] section — group rules by key, augment with type info from parsed entries
    output.push_str("[must]\n");
    if must_rules.is_empty() {
        output.push_str("# (no must rules defined)\n");
    } else {
        // Group must rules by key
        let parsed_rules: Vec<MustRule> = must_rules
            .iter()
            .filter_map(|r| parse_must_rule(r))
            .collect();
        let mut keys_seen: Vec<String> = Vec::new();

        for rule in &parsed_rules {
            if !keys_seen.contains(&rule.key) {
                keys_seen.push(rule.key.clone());
            }
        }

        for key in &keys_seen {
            let key_rules: Vec<&MustRule> = parsed_rules.iter().filter(|r| &r.key == key).collect();

            // Infer type from parsed entries if available
            let type_str = infer_type_for_key(key, parsed_entries);

            let constraints: Vec<String> = key_rules
                .iter()
                .map(|r| format!("{} {}", r.operator, r.value))
                .collect();

            output.push_str(&format!(
                "{} : {} {{ {} }}\n",
                key,
                type_str,
                constraints.join(", ")
            ));
        }
    }
    output.push('\n');

    // [trust] section
    output.push_str("[trust]\n");
    if trust_sources.is_empty() {
        output.push_str("# (no trust sources defined)\n");
    } else {
        for ts in trust_sources {
            if let Some(parsed) = parse_trust_source(ts) {
                output.push_str(&format!("{} = \"{}\"\n", parsed.trust_type, parsed.source));
            }
        }
    }
    output.push('\n');

    // [dust] section
    output.push_str("[dust]\n");
    if dust_rules.is_empty() {
        output.push_str("# (no dust rules defined)\n");
    } else {
        // Group dust rules by action
        let parsed: Vec<_> = dust_rules
            .iter()
            .filter_map(|d| parse_dust_rule(d))
            .collect();
        let mut actions_seen: Vec<String> = Vec::new();
        for d in &parsed {
            if !actions_seen.contains(&d.action) {
                actions_seen.push(d.action.clone());
            }
        }
        for action in &actions_seen {
            let targets: Vec<String> = parsed
                .iter()
                .filter(|d| &d.action == action)
                .map(|d| format!("\"{}\"", d.target))
                .collect();
            output.push_str(&format!("{} = [{}]\n", action, targets.join(", ")));
        }
    }
    output.push('\n');

    // [intend] section
    output.push_str("[intend]\n");
    if intend_declarations.is_empty() {
        output.push_str("# (no intend declarations defined)\n");
    } else {
        for decl in intend_declarations {
            output.push_str(&format!("{} = true\n", decl));
        }
    }

    output
}

/// Build an in-memory K9Contract struct from manifest data.
///
/// This is used by the validator to check configs against contracts
/// without needing to read from a .k9 file.
pub fn build_k9_contract(
    name: &str,
    source: &str,
    format: ConfigFormat,
    safety_tier: SafetyTier,
    must_rules: &[String],
    trust_sources: &[String],
    dust_rules: &[String],
    intend_declarations: &[String],
) -> K9Contract {
    K9Contract {
        name: name.to_string(),
        source: source.to_string(),
        format,
        safety_tier,
        must_rules: must_rules
            .iter()
            .filter_map(|r| parse_must_rule(r))
            .collect(),
        trust_sources: trust_sources
            .iter()
            .filter_map(|t| parse_trust_source(t))
            .collect(),
        dust_rules: dust_rules
            .iter()
            .filter_map(|d| parse_dust_rule(d))
            .collect(),
        intend_declarations: intend_declarations
            .iter()
            .map(|label| IntendDeclaration {
                label: label.clone(),
            })
            .collect(),
    }
}

/// Infer the K9 type string for a key based on parsed config entries.
///
/// Falls back to "string" if the key is not found in parsed entries.
fn infer_type_for_key(key: &str, parsed_entries: &[ParsedEntry]) -> &'static str {
    // Try exact match first, then try matching the last segment
    let entry = parsed_entries
        .iter()
        .find(|e| e.key == key || e.key.ends_with(&format!(".{}", key)));

    match entry {
        Some(e) => match e.value_type {
            ValueType::Int => "int",
            ValueType::Float => "float",
            ValueType::String => "string",
            ValueType::Bool => "bool",
            ValueType::Array => "array",
            ValueType::Table => "table",
        },
        None => "string",
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_generate_k9_contract_basic() {
        let content = generate_k9_contract(
            "app-config",
            SafetyTier::Kennel,
            &[
                "port > 0".into(),
                "port < 65536".into(),
                "host != ''".into(),
            ],
            &["signed-by: ci-pipeline".into()],
            &["remove: deprecated-keys".into()],
            &["production-ready".into()],
            &[
                ParsedEntry {
                    key: "port".into(),
                    value: "8080".into(),
                    value_type: ValueType::Int,
                },
                ParsedEntry {
                    key: "host".into(),
                    value: "localhost".into(),
                    value_type: ValueType::String,
                },
            ],
        );

        // K9! magic must be the first non-empty line (k9-validate-action).
        assert_eq!(content.lines().next(), Some("K9!"));
        // Mandatory pedigree block with name + version + leash.
        assert!(content.contains("pedigree = {"));
        assert!(content.contains("name = \"app-config\""));
        assert!(content.contains("leash = \"kennel\""));
        assert!(content.contains("# Auto-generated K9 contract for app-config"));
        assert!(content.contains("# Safety tier: kennel"));
        assert!(content.contains("[must]"));
        assert!(content.contains("port : int { > 0, < 65536 }"));
        assert!(content.contains("host : string { != '' }"));
        assert!(content.contains("[trust]"));
        assert!(content.contains("signed-by = \"ci-pipeline\""));
        assert!(content.contains("[dust]"));
        assert!(content.contains("remove = [\"deprecated-keys\"]"));
        assert!(content.contains("[intend]"));
        assert!(content.contains("production-ready = true"));
    }

    #[test]
    fn test_build_k9_contract_struct() {
        let contract = build_k9_contract(
            "test",
            "config/test.toml",
            ConfigFormat::Toml,
            SafetyTier::Yard,
            &["port > 0".into()],
            &["signed-by: ci".into()],
            &["remove: old-keys".into()],
            &["staging".into()],
        );

        assert_eq!(contract.name, "test");
        assert_eq!(contract.safety_tier, SafetyTier::Yard);
        assert_eq!(contract.must_rules.len(), 1);
        assert_eq!(contract.trust_sources.len(), 1);
        assert_eq!(contract.dust_rules.len(), 1);
        assert_eq!(contract.intend_declarations.len(), 1);
    }
}