zerum 0.1.0

Deterministic-first Python code governance: native checks (ZR001–ZR010), CLI, and SARIF/JSON reporters
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 crate::core::{Category, Check, Severity};
use serde::{Deserialize, Serialize};
use std::borrow::Cow;
use std::path::PathBuf;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ConfidenceKind {
    Deterministic,
    ToolReported,
    LlmInferred,
    ConsensusInferred,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Issue {
    pub id: String,
    pub title: String,
    pub message: String,
    pub explanation: Option<Cow<'static, str>>,
    pub remediation: Option<Cow<'static, str>>,
    pub file: PathBuf,
    pub line: usize,
    pub column: usize,
    pub severity: Severity,
    pub category: Category,
    pub source: String,
    pub confidence: ConfidenceKind,
}

/// Builds a deterministic [`Issue`] without a long positional argument list.
#[derive(Debug)]
pub struct IssueBuilder {
    id: String,
    title: String,
    message: String,
    file: PathBuf,
    line: usize,
    column: usize,
    severity: Severity,
    category: Category,
    explanation: Option<&'static str>,
    remediation: Option<&'static str>,
}

impl Issue {
    pub fn builder(
        id: impl Into<String>,
        title: impl Into<String>,
        message: impl Into<String>,
        file: PathBuf,
        line: usize,
        column: usize,
    ) -> IssueBuilder {
        IssueBuilder {
            id: id.into(),
            title: title.into(),
            message: message.into(),
            file,
            line,
            column,
            severity: Severity::Medium,
            category: Category::Design,
            explanation: None,
            remediation: None,
        }
    }

    pub fn from_check(
        check: &dyn Check,
        message: impl Into<String>,
        file: PathBuf,
        line: usize,
        column: usize,
    ) -> Self {
        Self::builder(check.id(), check.name(), message, file, line, column)
            .severity(check.severity())
            .category(check.category())
            .guidance(check.explanation(), check.remediation())
            .build()
    }
}

impl IssueBuilder {
    pub fn severity(mut self, severity: Severity) -> Self {
        self.severity = severity;
        self
    }

    pub fn category(mut self, category: Category) -> Self {
        self.category = category;
        self
    }

    pub fn guidance(mut self, explanation: &'static str, remediation: &'static str) -> Self {
        self.explanation = Some(explanation);
        self.remediation = Some(remediation);
        self
    }

    pub fn build(self) -> Issue {
        Issue {
            id: self.id,
            title: self.title,
            message: self.message,
            explanation: self.explanation.map(Cow::Borrowed),
            remediation: self.remediation.map(Cow::Borrowed),
            file: self.file,
            line: self.line,
            column: self.column,
            severity: self.severity,
            category: self.category,
            source: "zerum".to_string(),
            confidence: ConfidenceKind::Deterministic,
        }
    }
}