weavatrix-rust 2.1.1

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

//! Runtime-correctness review over local repository evidence.

mod rules;
mod source;
#[cfg(test)]
mod tests;

use crate::engine::RepositoryState;
use crate::operations::health::audit::severity_at_least;
use blazingly_json::{Value, json};
use rules::{RULES, finding_id};
use source::{async_context_lines, runtime_code};
use std::collections::BTreeSet;

pub(in crate::operations::health) use source::{product_sources, rust_cfg_test_lines};

/// One reviewable source: repository path, language identifier, and body.
pub(in crate::operations) type Source = (String, String, String);

/// Findings, files scanned, and whether the cap truncated the review.
pub(super) type RuntimeReview = (Vec<Value>, usize, bool);

/// Runs the rule set over arbitrary source text for worktree and Git baselines.
#[cfg(any(feature = "git", test))]
pub(in crate::operations::health) fn runtime_findings(
    sources: impl IntoIterator<Item = Source>,
    max: usize,
) -> RuntimeReview {
    runtime_findings_with_minimum(sources, max, 0)
}

fn runtime_findings_with_minimum(
    sources: impl IntoIterator<Item = Source>,
    max: usize,
    min_severity: u8,
) -> RuntimeReview {
    let mut findings = Vec::new();
    let mut scanned = 0_usize;
    let mut truncated = false;
    for (path, language, text) in sources {
        scanned += 1;
        let ignored_lines = if language == "rust" {
            rust_cfg_test_lines(&text)
        } else {
            BTreeSet::new()
        };
        let code = runtime_code(&path, &text);
        let async_lines = async_context_lines(&path, &language, &code);
        for (offset, (line, code_line)) in text.lines().zip(code.lines()).enumerate() {
            if ignored_lines.contains(&(offset + 1)) || line.len() > 400 {
                continue;
            }
            for rule in RULES {
                if !rule.languages.is_empty() && !rule.languages.contains(&language.as_str()) {
                    continue;
                }
                if !severity_at_least(rule.severity, min_severity) {
                    continue;
                }
                if rule.id == "runtime.blocking_call_in_async"
                    && !async_lines.contains(&(offset + 1))
                {
                    continue;
                }
                if (rule.matches)(code_line) {
                    if findings.len() >= max {
                        truncated = true;
                        break;
                    }
                    findings.push(json!({
                        "id": finding_id(rule.id, &path, line),
                        "rule": rule.id,
                        "category": "runtime",
                        "severity": rule.severity,
                        "file": path,
                        "line": offset + 1,
                        "language": language,
                        "message": rule.message,
                        "evidence": line.trim(),
                    }));
                }
            }
        }
    }
    findings.sort_by(|left, right| left["id"].as_str().cmp(&right["id"].as_str()));
    (findings, scanned, truncated)
}

/// Bounded runtime-correctness review over production source.
pub(super) fn runtime(
    state: &RepositoryState,
    max: usize,
    enabled: bool,
    min_severity: u8,
) -> Value {
    let threshold = if enabled { min_severity } else { u8::MAX };
    let (findings, scanned, truncated) =
        runtime_findings_with_minimum(product_sources(state), max, threshold);
    json!({
        "status": if findings.is_empty() {"PASS"} else {"REVIEW"},
        "execution": {"status": "COMPLETE"},
        "static_analysis": {
            "present": true,
            "scope": "bounded line-level rules over production source"
        },
        "runtime_evidence": {
            "present": false,
            "reason": "run_audit does not execute the repository or ingest profiler and telemetry data"
        },
        "rules": RULES.iter().map(|rule| rule.id).collect::<Vec<_>>(),
        "files_scanned": scanned,
        "findings_total": findings.len(),
        "truncated": truncated,
        "findings": findings,
        "caveat": "bounded syntax-context patterns over production source; no data-flow or execution",
    })
}