noether-engine 0.7.3

Noether composition engine: Lagrange graph AST, type checker, planner, executor, semantic index, LLM-backed composition agent
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

#![warn(clippy::unwrap_used)]
#![cfg_attr(test, allow(clippy::unwrap_used))]

use noether_core::stage::Stage;

/// Generate text for the signature index: "input_type -> output_type".
pub fn signature_text(stage: &Stage) -> String {
    format!("{} -> {}", stage.signature.input, stage.signature.output)
}

/// Generate text for the semantic/description index.
/// Aliases and tags are appended so that vocabulary-mismatched queries still
/// match (e.g. "strlen" → `text_length`, "network" → all IO stages).
pub fn description_text(stage: &Stage) -> String {
    let mut parts = vec![stage.description.clone()];
    if !stage.aliases.is_empty() {
        parts.push(format!("Aliases: {}", stage.aliases.join(", ")));
    }
    if !stage.tags.is_empty() {
        parts.push(format!("Tags: {}", stage.tags.join(", ")));
    }
    parts.join("\n")
}

/// Generate text for the example index: all input/output pairs.
pub fn examples_text(stage: &Stage) -> String {
    stage
        .examples
        .iter()
        .map(|ex| format!("{} => {}", ex.input, ex.output))
        .collect::<Vec<_>>()
        .join("\n")
}

#[cfg(test)]
mod tests {
    use super::*;
    use noether_core::effects::EffectSet;
    use noether_core::stage::{CostEstimate, Example, StageId, StageLifecycle, StageSignature};
    use noether_core::types::NType;
    use std::collections::BTreeSet;

    fn test_stage() -> Stage {
        Stage {
            id: StageId("test".into()),
            signature_id: None,
            signature: StageSignature {
                input: NType::Text,
                output: NType::Number,
                effects: EffectSet::pure(),
                implementation_hash: "impl".into(),
            },
            capabilities: BTreeSet::new(),
            cost: CostEstimate {
                time_ms_p50: None,
                tokens_est: None,
                memory_mb: None,
            },
            description: "Convert text to number".into(),
            examples: vec![
                Example {
                    input: serde_json::json!("42"),
                    output: serde_json::json!(42),
                },
                Example {
                    input: serde_json::json!("3"),
                    output: serde_json::json!(3),
                },
            ],
            lifecycle: StageLifecycle::Active,
            ed25519_signature: None,
            signer_public_key: None,
            implementation_code: None,
            implementation_language: None,
            ui_style: None,
            tags: vec![],
            aliases: vec![],
            name: None,
            properties: Vec::new(),
        }
    }

    #[test]
    fn signature_text_formats_types() {
        let stage = test_stage();
        assert_eq!(signature_text(&stage), "Text -> Number");
    }

    #[test]
    fn description_text_returns_description() {
        let stage = test_stage();
        assert_eq!(description_text(&stage), "Convert text to number");
    }

    #[test]
    fn description_text_appends_aliases_and_tags() {
        let mut stage = test_stage();
        stage.aliases = vec!["parse_float".into(), "atof".into()];
        stage.tags = vec!["scalar".into(), "pure".into()];
        let text = description_text(&stage);
        assert!(text.starts_with("Convert text to number"));
        assert!(text.contains("Aliases: parse_float, atof"));
        assert!(text.contains("Tags: scalar, pure"));
    }

    #[test]
    fn examples_text_formats_pairs() {
        let stage = test_stage();
        let text = examples_text(&stage);
        assert!(text.contains("\"42\" => 42"));
        assert!(text.contains("\"3\" => 3"));
    }
}