weavatrix-rust 2.16.0

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
118
119
120
121
122
123
124
125
126

use crate::engine::RepositoryState;
use crate::operations::source;
use blazingly_json::{Value, json};
use weavatrix_graph::{EdgeKind, Node};

pub(super) fn nodes<'a>(
    state: &'a RepositoryState,
    kind: &str,
    path: Option<&str>,
) -> Vec<&'a Node> {
    state
        .graph()
        .nodes()
        .iter()
        .filter(|node| node.kind.as_str() == kind)
        .filter(|node| path.is_none_or(|filter| in_path(node, filter)))
        .collect()
}

pub(super) fn in_path(node: &Node, filter: &str) -> bool {
    node.span
        .as_ref()
        .is_some_and(|span| span.file == filter || span.file.contains(filter))
}

pub(super) fn row(state: &RepositoryState, node: &Node) -> Value {
    let domains = owned_domains(state, node.id.as_str());
    json!({
        "id": node.id,
        "label": node.label,
        "kind": node.kind,
        "span": node.span,
        "profile": domain_name(&domains, "profile:"),
        "package": domain_name(&domains, "package:"),
        "completeness": domain_name(&domains, "completeness:"),
        "schema": domain_name(&domains, "schema:"),
        "transport": domain_name(&domains, "transport:"),
        "authorization": domain_name(&domains, "authorization:").unwrap_or_else(|| "none".to_owned()),
        "relations": domains
    })
}

pub(super) fn selected(node: &Node) -> Value {
    json!({
        "id": node.id,
        "label": node.label,
        "kind": node.kind,
        "span": node.span
    })
}

pub(super) fn owned_domains(state: &RepositoryState, owner: &str) -> Vec<Value> {
    state
        .graph()
        .edges()
        .iter()
        .filter(|edge| edge.source.as_str() == owner)
        .filter_map(|edge| {
            let node = state.graph().node(edge.target.as_str())?;
            Some(json!({
                "id": node.id,
                "name": node.label,
                "kind": node.kind,
                "relation": edge.kind,
                "span": node.span
            }))
        })
        .collect()
}

pub(super) fn children(state: &RepositoryState, owner: &str) -> Vec<Value> {
    state
        .graph()
        .edges()
        .iter()
        .filter(|edge| edge.source.as_str() == owner && edge.kind == EdgeKind::Contains)
        .filter_map(|edge| {
            let node = state.graph().node(edge.target.as_str())?;
            Some(selected(node))
        })
        .collect()
}

pub(super) fn coverage(state: &RepositoryState, path: Option<&str>) -> Value {
    json!({
        "plugins": nodes(state, "agent.plugin", path).len(),
        "skills": nodes(state, "agent.skill", path).len(),
        "mcp_servers": nodes(state, "agent.mcp_server", path).len(),
        "catalogs": nodes(state, "agent.catalog", path).len(),
        "tools": nodes(state, "agent.tool", path).len(),
        "observations": nodes(state, "agent.observation", path).len(),
        "runtime": {"provided": false},
        "executed": false,
        "authorization": "none"
    })
}

pub(super) fn fragments(state: &RepositoryState, node: &Node) -> Vec<Value> {
    if node.span.is_none() {
        return Vec::new();
    }
    let Ok(source) = source::read_source(
        state,
        &json!({
            "label": node.id.as_str(),
            "before": 1,
            "after": 16
        }),
    ) else {
        return Vec::new();
    };
    vec![json!({
        "path": source["path"],
        "start_line": source["start_line"],
        "lines": source["lines"]
    })]
}

fn domain_name(domains: &[Value], prefix: &str) -> Option<String> {
    domains.iter().find_map(|item| {
        item["name"]
            .as_str()
            .and_then(|name| name.strip_prefix(prefix))
            .map(ToOwned::to_owned)
    })
}