weavatrix-rust 2.14.3

Protocol-independent Rust repository intelligence: typed evidence graphs for impact, architecture, APIs, Git, search, and memory
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

use super::model::{AppRecord, DomainRecord, node_key};
use crate::language::yaml_doc::{self, Node};
use weavatrix_graph::NodeKind;

pub(super) fn collect(record: &mut AppRecord, root: &Node, nodes: &[Node], path: &str, raw: &str) {
    if let Some(dependencies) = root.get("dependencies").and_then(Node::items) {
        for item in dependencies {
            let name = item
                .as_str()
                .or_else(|| item.get("name").and_then(Node::as_str))
                .unwrap_or("plugin");
            record.domains.push(domain(
                &record.key,
                format!("plugin:{name}"),
                "imports_plugin",
                record.span.clone(),
            ));
        }
    }
    for node in nodes {
        let Some(id) = node.get("id").and_then(Node::as_str) else {
            continue;
        };
        let owner = node_key(&record.key, id);
        let data = node.get("data");
        if let Some(model) = data.and_then(|data| data.get("model")) {
            if let Some(selector) = model
                .get("model_selector")
                .or_else(|| data.and_then(|data| data.get("model_selector")))
            {
                env_model(record, &owner, selector, path, raw);
            }
            if let Some(name) = model.get("name").and_then(Node::as_str) {
                let provider = model.get("provider").and_then(Node::as_str).unwrap_or("");
                record.domains.push(domain(
                    &owner,
                    format!("model:{provider}:{name}"),
                    "uses_model",
                    span(path, raw, model),
                ));
            }
        }
        if let Some(tools) = data
            .and_then(|data| data.get("tools"))
            .and_then(Node::items)
        {
            for tool in tools {
                let name = tool
                    .get("provider_name")
                    .or_else(|| tool.get("name"))
                    .and_then(Node::as_str)
                    .unwrap_or("tool");
                record.domains.push(domain(
                    &owner,
                    format!("tool:{name}"),
                    "invokes_tool",
                    span(path, raw, tool),
                ));
            }
        }
        if data
            .and_then(|data| data.get("type"))
            .and_then(Node::as_str)
            == Some("knowledge-retrieval")
        {
            record.domains.push(domain(
                &owner,
                "knowledge:configured",
                "queries_knowledge",
                span(path, raw, node),
            ));
        }
    }
}

fn env_model(record: &mut AppRecord, owner: &str, selector: &Node, path: &str, raw: &str) {
    let segments = selector
        .items()
        .map(|items| items.iter().filter_map(Node::as_str).collect::<Vec<_>>())
        .unwrap_or_default();
    if segments.first() == Some(&"env") {
        let name = segments.get(1).copied().unwrap_or("MODEL");
        record.domains.push(domain(
            owner,
            format!("model:env:{name}"),
            "uses_model",
            span(path, raw, selector),
        ));
    }
}

fn domain(
    owner: &str,
    name: impl Into<String>,
    relation: &str,
    span: weavatrix_graph::SourceSpan,
) -> DomainRecord {
    let relation = match relation {
        "uses_model" => super::model::uses_model(),
        "invokes_tool" => super::model::invokes_tool(),
        "queries_knowledge" => super::model::queries_knowledge(),
        "imports_plugin" => super::model::imports_plugin(),
        _ => weavatrix_graph::EdgeKind::Configures,
    };
    DomainRecord {
        owner: owner.to_owned(),
        name: name.into(),
        kind: NodeKind::Unknown,
        relation,
        span,
    }
}

fn span(path: &str, raw: &str, node: &Node) -> weavatrix_graph::SourceSpan {
    let (start, end) = node.range();
    yaml_doc::span_for(path, raw, start, end)
}