Struct LintConfig 

pub struct LintConfig { /* private fields */ }

Configuration for the linter

Cheap Cloning via Arc<ConfigData>

All serializable fields are stored in a shared Arc<ConfigData>. Cloning a LintConfig bumps the Arc refcount and shallow-copies the lightweight RuntimeContext - no heap-allocated Vec<String> or nested structs are deep-copied. Setters use Arc::make_mut for copy-on-write semantics, so mutations only allocate when the Arc is shared.

Implementations

impl LintConfig

pub fn builder() -> LintConfigBuilder

Create a new LintConfigBuilder for constructing a LintConfig.

impl LintConfig

pub fn is_rule_enabled(&self, rule_id: &str) -> bool

Check if a specific rule is enabled based on config

A rule is enabled if:

1. It’s not in the disabled_rules list
2. It’s applicable to the current target tool
3. Its category is enabled

This delegates to DefaultRuleFilter which encapsulates the filtering logic.

pub fn is_tool_alias(user_tool: &str, canonical_tool: &str) -> bool

Check if a user-provided tool name is a backward-compatible alias for the canonical tool name from rules.json.

Currently only “github-copilot” has an alias (“copilot”). This exists for backward compatibility: early versions of agnix used the shorter “copilot” name in configs, and we need to continue supporting that for existing users. The canonical names in rules.json use the full “github-copilot” to match the official tool name from GitHub’s documentation.

Note: This function does NOT treat canonical names as aliases of themselves. For example, “github-copilot” is NOT an alias for “github-copilot” - that’s handled by the direct eq_ignore_ascii_case comparison in is_rule_for_tools().

impl LintConfig

pub fn validate(&self) -> Vec<ConfigWarning>

Validate the configuration and return any warnings.

This performs semantic validation beyond what TOML parsing can check:

• Validates that disabled_rules match known rule ID patterns
• Validates that tools array contains known tool names
• Warns on deprecated fields

impl LintConfig

pub fn load<P: AsRef<Path>>(path: P) -> Result<Self>

Load config from file

pub fn load_or_default(path: Option<&PathBuf>) -> (Self, Option<String>)

Load config or use default, returning any parse warning

Returns a tuple of (config, optional_warning). If a config path is provided but the file cannot be loaded or parsed, returns the default config with a warning message describing the error. This prevents silent fallback to defaults on config typos or missing/unreadable config files.

pub fn root_dir(&self) -> Option<&PathBuf>

Get the runtime validation root directory, if set.

pub fn get_root_dir(&self) -> Option<&PathBuf>

Alias for root_dir() for consistency with other accessors.

pub fn set_root_dir(&mut self, root_dir: PathBuf)

Set the runtime validation root directory (not persisted).

pub fn set_import_cache( &mut self, cache: Arc<RwLock<HashMap<PathBuf, Vec<Import>>>>, )

Set the shared import cache for project-level validation (not persisted).

When set, the ImportsValidator will use this cache to share parsed import data across files, improving performance by avoiding redundant parsing during import chain traversal.

pub fn import_cache( &self, ) -> Option<&Arc<RwLock<HashMap<PathBuf, Vec<Import>>>>>

Get the shared import cache, if one has been set.

Returns None for single-file validation or when the cache hasn’t been initialized. Returns Some(&ImportCache) during project-level validation where import results are shared across files.

pub fn get_import_cache( &self, ) -> Option<&Arc<RwLock<HashMap<PathBuf, Vec<Import>>>>>

Alias for import_cache() for consistency with other accessors.

pub fn fs(&self) -> &Arc<dyn FileSystem>

Get the file system abstraction.

Validators should use this for file system operations instead of directly calling std::fs functions. This enables unit testing with MockFileSystem.

pub fn set_fs(&mut self, fs: Arc<dyn FileSystem>)

Set the file system abstraction (not persisted).

This is primarily used for testing with MockFileSystem.

Important

This should only be called during configuration setup, before validation begins. Changing the filesystem during validation may cause inconsistent results if validators have already cached file state.

pub fn severity(&self) -> SeverityLevel

Get the severity level threshold.

pub fn rules(&self) -> &RuleConfig

Get the rules configuration.

pub fn exclude(&self) -> &[String]

Get the exclude patterns.

pub fn target(&self) -> TargetTool

Get the target tool.

pub fn tools(&self) -> &[String]

Get the tools list.

pub fn tool_versions(&self) -> &ToolVersions

Get the tool versions configuration.

pub fn spec_revisions(&self) -> &SpecRevisions

Get the spec revisions configuration.

pub fn files_config(&self) -> &FilesConfig

Get the files configuration.

pub fn locale(&self) -> Option<&str>

Get the locale, if set.

pub fn max_files_to_validate(&self) -> Option<usize>

Get the maximum number of files to validate.

pub fn mcp_protocol_version_raw(&self) -> Option<&str>

Get the raw mcp_protocol_version field value (without fallback logic).

For the resolved version with fallback, use get_mcp_protocol_version().

pub fn set_severity(&mut self, severity: SeverityLevel)

Set the severity level threshold.

pub fn set_target(&mut self, target: TargetTool)

Set the target tool.

pub fn set_tools(&mut self, tools: Vec<String>)

Set the tools list.

pub fn tools_mut(&mut self) -> &mut Vec<String>

Get a mutable reference to the tools list.

pub fn set_exclude(&mut self, exclude: Vec<String>)

Set the exclude patterns.

Note: This does not validate the patterns. Call validate() after using this if validation is needed.

pub fn set_locale(&mut self, locale: Option<String>)

Set the locale.

pub fn set_max_files_to_validate(&mut self, max: Option<usize>)

Set the maximum number of files to validate.

pub fn set_mcp_protocol_version(&mut self, version: Option<String>)

Set the MCP protocol version (deprecated field).

pub fn rules_mut(&mut self) -> &mut RuleConfig

Get a mutable reference to the rules configuration.

pub fn tool_versions_mut(&mut self) -> &mut ToolVersions

Get a mutable reference to the tool versions configuration.

pub fn spec_revisions_mut(&mut self) -> &mut SpecRevisions

Get a mutable reference to the spec revisions configuration.

pub fn files_mut(&mut self) -> &mut FilesConfig

Get a mutable reference to the files configuration.

Note: Mutations bypass builder validation. Call validate() after modifying if validation is needed.

pub fn get_mcp_protocol_version(&self) -> &str

Get the expected MCP protocol version

Priority: spec_revisions.mcp_protocol > mcp_protocol_version > default

pub fn is_mcp_revision_pinned(&self) -> bool

Check if MCP protocol revision is explicitly pinned

pub fn is_claude_code_version_pinned(&self) -> bool

Check if Claude Code version is explicitly pinned

pub fn get_claude_code_version(&self) -> Option<&str>

Get the pinned Claude Code version, if any

Trait Implementations

impl Clone for LintConfig

fn clone(&self) -> LintConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LintConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for LintConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LintConfig

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl JsonSchema for LintConfig

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Serialize for LintConfig

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.