audit

type EffectiveConfiguration ¶ added in v0.2.4

type EffectiveConfiguration struct {
	Exclude     []string                   `json:"exclude"`
	Suppress    []string                   `json:"suppress,omitempty"`
	FailOn      string                     `json:"fail_on,omitempty"`
	Mixed       MixedConfiguration         `json:"mixed"`
	LayerPolicy []LayerPolicyConfiguration `json:"layer_policy,omitempty"`
}

EffectiveConfiguration records the policy actually used for an audit. It is deliberately resolved (defaults, repository config, and CLI overrides) so a saved JSON report can be reproduced without reconstructing flag precedence.

type Finding ¶

type Finding struct {
	Smell      string         `json:"smell"`
	SmellID    string         `json:"smell_id"`
	Severity   Severity       `json:"severity"`
	Location   string         `json:"location"`
	Message    string         `json:"message"`
	Evidence   map[string]any `json:"evidence,omitempty"`
	Suggestion string         `json:"suggestion,omitempty"`
}

Finding is one entry in a lagotto audit. Every detector emits zero or more findings; the JSON shape is the stable downstream contract.

Field semantics:

• Smell: human-readable name ("Receiver Monolith")
• SmellID: short stable ID ("G1") — use this in tooling
• Severity: CRITICAL | HIGH | MEDIUM | LOW
• Location: stable import path plus file/type/symbol where applicable
• Message: one-line summary suitable for a terminal
• Evidence: structured per-detector data (method counts, file lists, package paths) for tooling that wants to drill in
• Suggestion: concrete imperative remediation guidance

func ApplySuppressions(findings []Finding, raw []string) ([]Finding, int, error)

func ConsolidateRepositoryPatterns(findings []Finding) []Finding

type FindingsError ¶ added in v0.2.0

type FindingsError struct {
	Count     int
	Threshold Severity
}

FindingsError signals that findings met the --fail-on threshold. The run itself succeeded — the report was emitted — so main translates this into exit code 2, distinguishing "findings found" (2) from "run failed" (1).

func (e *FindingsError) Error() string

type IncompleteLoadError ¶ added in v0.2.4

type IncompleteLoadError struct {
	Count int
}

IncompleteLoadError means the report was emitted, but one or more packages did not load or type-check completely. Callers must treat this as a failed audit rather than a clean result.

func (e *IncompleteLoadError) Error() string

type LayerPolicyConfiguration ¶ added in v0.2.4

type LayerPolicyConfiguration struct {
	Name                       string   `json:"name"`
	Paths                      []string `json:"paths"`
	Dependencies               []string `json:"dependencies"`
	GeneratedTypes             []string `json:"generated_types"`
	MaxCoordinatedDependencies int      `json:"max_coordinated_dependencies"`
	Severity                   Severity `json:"severity"`
}

LayerPolicyConfiguration records one resolved G14 policy.

type MixedConfiguration ¶ added in v0.2.4

type MixedConfiguration struct {
	MinLines                     int      `json:"min_lines"`
	MinComponentMembers          int      `json:"min_component_members"`
	MinComponentLines            int      `json:"min_component_lines"`
	MinSingleComponentComplexity int      `json:"min_single_component_complexity"`
	Severity                     Severity `json:"severity"`
	CohesiveMinLines             int      `json:"cohesive_min_lines"`
}

MixedConfiguration is the resolved policy for G5 and G13.

type Report ¶

type Report struct {
	Version            string                 `json:"version"`
	Root               string                 `json:"root"`
	Config             string                 `json:"config,omitempty"`
	Configuration      EffectiveConfiguration `json:"configuration"`
	Tags               []string               `json:"tags,omitempty"`
	LoadErrors         []string               `json:"load_errors,omitempty"`
	SuppressedFindings int                    `json:"suppressed_findings,omitempty"`
	Findings           []Finding              `json:"findings"`
}

Report is the top-level audit envelope written to stdout. Root is the path the audit was run against, Tags echoes the build tags the loader used, and Findings is severity-sorted (CRITICAL first). LoadErrors carries per-package load/type errors so JSON consumers can tell a clean audit from a degraded one; when it is non-empty, detectors may have skipped the affected packages.

type Severity ¶

type Severity string

Severity ranks findings from CRITICAL (always investigate) down to LOW (worth knowing about, low blast radius). Severity is a string so the JSON output is human-readable.

const (
	SevCritical Severity = "CRITICAL"
	SevHigh     Severity = "HIGH"
	SevMedium   Severity = "MEDIUM"
	SevLow      Severity = "LOW"
)

func ParseSeverity(s string) (Severity, bool)

func (s Severity) AtLeast(threshold Severity) bool