fensu-cli 0.5.0__tar.gz → 0.6.0__tar.gz

{fensu_cli-0.5.0 → fensu_cli-0.6.0}/Cargo.lock

@@ -392,7 +392,7 @@ checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
 
 [[package]]
 name = "fensu-cli"
-version = "0.5.0"
+version = "0.6.0"
 dependencies = [
  "cap-fs-ext",
  "cap-std",

{fensu_cli-0.5.0 → fensu_cli-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fensu-cli
-Version: 0.5.0
+Version: 0.6.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License

{fensu_cli-0.5.0 → fensu_cli-0.6.0}/crates/fensu-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fensu-cli"
-version = "0.5.0" # x-release-please-version
+version = "0.6.0" # x-release-please-version
 edition.workspace = true
 license.workspace = true
 publish = false

{fensu_cli-0.5.0 → fensu_cli-0.6.0}/crates/fensu-cli/src/command/helpers/memory_execution.rs

@@ -23,7 +23,7 @@ use crate::command::helpers::{
 };
 use crate::command::models::{ColorMode, MemoryCommand, MemoryProject};
 use crate::configuration::main::load;
-use crate::helpers::render;
+use crate::helpers::reporting::render;
 use crate::models::{CliOutput, Fault};
 
 pub(crate) fn execute_memory(arguments: &[String]) -> Result<CliOutput, String> {

{fensu_cli-0.5.0 → fensu_cli-0.6.0}/crates/fensu-cli/src/command/main/check.rs

@@ -1,4 +1,4 @@
-use crate::helpers::check_execution::execute_check;
+use crate::helpers::check::execution::execute_check;
 use crate::models::CliOutput;
 
 pub(crate) fn run(arguments: &[String]) -> Result<CliOutput, String> {

{fensu_cli-0.5.0 → fensu_cli-0.6.0}/crates/fensu-cli/src/command/main/init.rs

@@ -1,4 +1,4 @@
-use crate::helpers::init::run_init;
+use crate::helpers::init::run::run_init;
 use crate::models::CliOutput;
 
 pub(crate) fn init(arguments: &[String]) -> Result<CliOutput, String> {

{fensu_cli-0.5.0 → fensu_cli-0.6.0}/crates/fensu-cli/src/command/main/rule.rs

@@ -1,4 +1,4 @@
-use crate::helpers::rule::rule_output;
+use crate::helpers::catalogue::metadata::rule_output;
 use crate::models::CliOutput;
 
 pub(crate) fn rule(arguments: &[String]) -> Result<CliOutput, String> {

{fensu_cli-0.5.0 → fensu_cli-0.6.0}/crates/fensu-cli/src/command/main/run_cli.rs

@@ -3,7 +3,8 @@ use std::path::Path;
 
 use crate::command::main::{check, help, init, map, memory, rule, skills};
 use crate::configuration::main::custom_rules;
-use crate::helpers::{check_cleanup, process};
+use crate::helpers::check::cleanup;
+use crate::helpers::hosting::process;
 use crate::models::CliOutput;
 
 pub fn run_cli() -> CliOutput {
@@ -40,7 +41,7 @@ fn dispatch(arguments: &[String]) -> Result<CliOutput, String> {
 }
 
 fn dispatch_check(arguments: &[String]) -> Result<CliOutput, String> {
-    let cleanup = check_cleanup::prepare(Path::new("."));
+    let cleanup = cleanup::prepare(Path::new("."));
     let result = if custom_rules::custom_rules_are_configured(Path::new("."))? {
         let exit_code = process::run_custom_check_host(arguments)?;
         Ok(CliOutput {

{fensu_cli-0.5.0 → fensu_cli-0.6.0}/crates/fensu-cli/src/configuration/helpers/mod.rs

@@ -2,4 +2,5 @@ pub(crate) mod discovery;
 pub(crate) mod exceptions;
 pub(crate) mod loading;
 pub(crate) mod parsing;
+pub(crate) mod roots;
 pub(crate) mod validation;

fensu_cli-0.6.0/crates/fensu-cli/src/configuration/helpers/roots.rs

@@ -0,0 +1,30 @@
+pub(crate) fn validate_nested_roots(roots: Vec<String>) -> Result<(), String> {
+    for (index, first) in roots.iter().enumerate() {
+        let first_parts = first.split('/').collect::<Vec<_>>();
+        for second in roots.iter().skip(index + 1) {
+            let second_parts = second.split('/').collect::<Vec<_>>();
+            let length = first_parts.len().min(second_parts.len());
+            if first_parts[..length] != second_parts[..length] {
+                continue;
+            }
+            return Err(nested_roots_error(
+                first,
+                second,
+                first_parts.len() <= second_parts.len(),
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn nested_roots_error(first: &str, second: &str, first_is_outer: bool) -> String {
+    let (outer, inner) = if first_is_outer {
+        (first, second)
+    } else {
+        (second, first)
+    };
+    if outer == inner {
+        return format!("Config key roots must not contain duplicate paths: {outer:?}.");
+    }
+    format!("Config key roots must not contain nested paths: {outer:?} contains {inner:?}.")
+}

{fensu_cli-0.5.0 → fensu_cli-0.6.0}/crates/fensu-cli/src/configuration/helpers/validation.rs

@@ -1,6 +1,7 @@
 use std::collections::HashSet;
 
 use crate::configuration::helpers::exceptions;
+use crate::configuration::helpers::roots::validate_nested_roots;
 use crate::constants::{
     CONFIG_ROLE_NAMES, CONTRACT_BEHAVIORS, DEFAULT_THRESHOLDS, MAX_CORE_SELECTOR_SUFFIX,
 };
@@ -78,20 +79,6 @@ fn validate_rule_options(value: Option<&toml::Value>) -> Result<(), String> {
     Ok(())
 }
 
-fn validate_nested_roots(roots: Vec<String>) -> Result<(), String> {
-    for (index, first) in roots.iter().enumerate() {
-        let first = first.split('/').collect::<Vec<_>>();
-        for second in roots.iter().skip(index + 1) {
-            let second = second.split('/').collect::<Vec<_>>();
-            let length = first.len().min(second.len());
-            if first[..length] == second[..length] {
-                return Err("Config key roots must not contain nested paths.".to_owned());
-            }
-        }
-    }
-    Ok(())
-}
-
 fn validate_boolean_table(
     table: &toml::map::Map<String, toml::Value>,
     name: &str,

{fensu_cli-0.5.0 → fensu_cli-0.6.0}/crates/fensu-cli/src/configuration/main/mod.rs

@@ -1,3 +1,4 @@
 pub(crate) mod custom_rules;
 pub(crate) mod load;
 pub(crate) mod load_optional;
+pub(crate) mod validate_document;

fensu_cli-0.6.0/crates/fensu-cli/src/configuration/main/validate_document.rs

@@ -0,0 +1,10 @@
+use crate::configuration::helpers::validation;
+
+pub(crate) fn validate_document(text: &str) -> Result<(), String> {
+    let document = toml::from_slice::<toml::Value>(text.as_bytes())
+        .map_err(|error| format!("Configuration is not valid TOML: {error}"))?;
+    let table = document
+        .as_table()
+        .ok_or_else(|| "Configuration did not contain a TOML table.".to_owned())?;
+    validation::validate(table)
+}

fensu_cli-0.6.0/crates/fensu-cli/src/helpers/catalogue/mod.rs

@@ -0,0 +1 @@
+pub(crate) mod metadata;

fensu_cli-0.5.0/crates/fensu-cli/src/helpers/check_evaluation.rs → fensu_cli-0.6.0/crates/fensu-cli/src/helpers/check/evaluation.rs

@@ -9,12 +9,13 @@ use rayon::iter::{IndexedParallelIterator, IntoParallelRefIterator, ParallelIter
 use crate::constants::{
     OWNER_FILE, OWNER_PACKAGE, ROLE_HELPERS, ROLE_MAIN, SCOPE_TEST, SUFFIX_INIT,
 };
-use crate::helpers::check_policy::{
+use crate::helpers::catalogue::metadata;
+use crate::helpers::check::policy::{
     apply_exceptions, apply_rule_ignores, is_entry_module, is_main_module, program,
     resolved_thresholds, role, scope_roots, source_module_name,
 };
-use crate::helpers::check_project::{observe, project_plane};
-use crate::helpers::{render, rule};
+use crate::helpers::check::project::{observe, project_plane};
+use crate::helpers::reporting::render;
 use crate::models::{Config, Fault, RuleMetadata, ScopedSource};
 
 pub(crate) fn evaluate_and_render(
@@ -86,7 +87,7 @@ pub(crate) fn evaluate_and_render(
             let faults = rows
                 .into_iter()
                 .map(|row| {
-                    let metadata = rule::rule(&row.code)
+                    let metadata = metadata::rule(&row.code)
                         .ok_or_else(|| format!("Unknown native rule code: {}", row.code))?;
                     let path = row.path.unwrap_or_else(|| source.repository_path.clone());
                     Ok(Fault {
@@ -162,7 +163,8 @@ fn native_rule_options(
 ) -> Result<HashMap<String, HashMap<String, String>>, String> {
     let mut by_code = HashMap::new();
     for code in codes {
-        let rule = rule::rule(code).ok_or_else(|| format!("Unknown native rule code: {code}"))?;
+        let rule =
+            metadata::rule(code).ok_or_else(|| format!("Unknown native rule code: {code}"))?;
         let mut values = HashMap::new();
         for option in &rule.options {
             values.insert(
@@ -178,7 +180,7 @@ fn native_rule_options(
 }
 
 pub(crate) fn selected_rules(select: &[String], ignore: &[String]) -> Vec<&'static RuleMetadata> {
-    rule::catalogue()
+    metadata::catalogue()
         .iter()
         .filter(|rule| {
             let selected = select

fensu_cli-0.5.0/crates/fensu-cli/src/helpers/check_execution.rs → fensu_cli-0.6.0/crates/fensu-cli/src/helpers/check/execution.rs

@@ -8,9 +8,9 @@ use walkdir::WalkDir;
 
 use crate::configuration::main::load;
 use crate::constants::PYTHON_CACHE_DIRECTORY;
-use crate::helpers::cache;
-use crate::helpers::check_evaluation::evaluate_and_render;
-use crate::helpers::check_policy::{
+use crate::helpers::check::cache;
+use crate::helpers::check::evaluation::evaluate_and_render;
+use crate::helpers::check::policy::{
     check_identity, hex_digest, path_matches, python_version, validate_package_names,
 };
 use crate::models::{CachedOutput, CheckOptions, CliOutput, Config, ScopedSource};

fensu_cli-0.6.0/crates/fensu-cli/src/helpers/check/mod.rs

@@ -0,0 +1,6 @@
+pub(crate) mod cache;
+pub(crate) mod cleanup;
+pub(crate) mod evaluation;
+pub(crate) mod execution;
+pub(crate) mod policy;
+pub(crate) mod project;

fensu_cli-0.5.0/crates/fensu-cli/src/helpers/check_project.rs → fensu_cli-0.6.0/crates/fensu-cli/src/helpers/check/project.rs

@@ -8,7 +8,7 @@ use globset::GlobBuilder;
 use walkdir::WalkDir;
 
 use crate::constants::{SCOPE_TEST, STEM_INIT, VALUE_TRUE};
-use crate::helpers::check_policy::{bool_text, program, python_version, relative};
+use crate::helpers::check::policy::{bool_text, program, python_version, relative};
 use crate::models::{Config, ScopedSource};
 
 const ENTRYPOINT_SECTIONS: [&str; 3] = ["scripts", "gui-scripts", "entry-points"];

fensu_cli-0.6.0/crates/fensu-cli/src/helpers/hosting/mod.rs

@@ -0,0 +1 @@
+pub(crate) mod process;

fensu_cli-0.6.0/crates/fensu-cli/src/helpers/init/mod.rs

@@ -0,0 +1,2 @@
+pub(crate) mod packages;
+pub(crate) mod run;

fensu_cli-0.6.0/crates/fensu-cli/src/helpers/init/packages.rs

@@ -0,0 +1,90 @@
+use std::collections::BTreeSet;
+use std::fs;
+use std::path::Path;
+
+use walkdir::WalkDir;
+
+const MAX_REPORTED_DIRECTORIES: usize = 10;
+const SKIPPED_DIRECTORIES: [&str; 7] = [
+    ".git",
+    ".venv",
+    "venv",
+    "target",
+    "dist",
+    "build",
+    "__pycache__",
+];
+
+pub(crate) fn implicit_namespace_packages(repository: &Path, roots: &[String]) -> Vec<String> {
+    let mut found = BTreeSet::new();
+    for root in roots {
+        for entry in WalkDir::new(repository.join(root))
+            .into_iter()
+            .filter_entry(is_walkable)
+            .filter_map(Result::ok)
+        {
+            let path = entry.path();
+            if !entry.file_type().is_dir() || path.join("__init__.py").is_file() {
+                continue;
+            }
+            if !holds_python_code(path) {
+                continue;
+            }
+            if let Ok(relative) = path.strip_prefix(repository) {
+                found.insert(relative.to_string_lossy().replace('\\', "/"));
+            }
+        }
+    }
+    found.into_iter().collect()
+}
+
+pub(crate) fn report(directories: &[String]) -> String {
+    if directories.is_empty() {
+        return String::new();
+    }
+    let count = directories.len();
+    let noun = if count == 1 {
+        "directory holds"
+    } else {
+        "directories hold"
+    };
+    let mut text = format!("\n-> Implicit namespace packages\n\n    {count} {noun} Python code but no __init__.py:\n\n");
+    for directory in directories.iter().take(MAX_REPORTED_DIRECTORIES) {
+        text.push_str(&format!("      {directory}\n"));
+    }
+    if let Some(remaining) = count
+        .checked_sub(MAX_REPORTED_DIRECTORIES)
+        .filter(|value| *value > 0)
+    {
+        text.push_str(&format!("      ... and {remaining} more\n"));
+    }
+    text.push_str(
+        "\n    Add __init__.py to each one unless the namespace package is deliberate.\n",
+    );
+    text
+}
+
+fn is_walkable(entry: &walkdir::DirEntry) -> bool {
+    entry
+        .file_name()
+        .to_str()
+        .is_none_or(|name| !SKIPPED_DIRECTORIES.contains(&name))
+}
+
+fn holds_python_code(directory: &Path) -> bool {
+    let Ok(entries) = fs::read_dir(directory) else {
+        return false;
+    };
+    let mut children = entries.filter_map(Result::ok);
+    children.any(|child| is_python_module(&child) || is_package_directory(&child))
+}
+
+fn is_python_module(child: &fs::DirEntry) -> bool {
+    child.path().is_file()
+        && child.path().extension().and_then(|value| value.to_str()) == Some("py")
+        && child.file_name().to_str() != Some("__init__.py")
+}
+
+fn is_package_directory(child: &fs::DirEntry) -> bool {
+    child.path().is_dir() && child.path().join("__init__.py").is_file()
+}

fensu_cli-0.5.0/crates/fensu-cli/src/helpers/init.rs → fensu_cli-0.6.0/crates/fensu-cli/src/helpers/init/run.rs

@@ -6,6 +6,9 @@ use std::path::{Path, PathBuf};
 
 use walkdir::WalkDir;
 
+use crate::configuration::main::load;
+use crate::configuration::main::validate_document::validate_document;
+use crate::helpers::init::packages;
 use crate::models::{CliOutput, InitOptions};
 use crate::skills::main::execute;
 use crate::skills::models::SkillOptions;
@@ -19,10 +22,7 @@ pub(crate) fn run_init(arguments: &[String]) -> Result<CliOutput, String> {
     }
     let repository = env::current_dir().map_err(|error| error.to_string())?;
     if let Some(path) = local_config(&repository) {
-        return Ok(CliOutput::success(format!(
-            "Fensu configuration already exists: {} (nothing to do)\n",
-            path.display()
-        )));
+        return existing_configuration(&repository, &path, &options);
     }
     let python_files = repository_python_files(&repository);
     let package_roots = detected_roots(&repository);
@@ -81,6 +81,10 @@ pub(crate) fn run_init(arguments: &[String]) -> Result<CliOutput, String> {
             .sum::<usize>();
         output.push_str(&format!("-> Existing codebase - {runtime_count} Python files\n\n    Enabling the full Fensu ruleset: FF\n    Wrote fensu.toml\n"));
     }
+    output.push_str(&packages::report(&packages::implicit_namespace_packages(
+        &repository,
+        &roots,
+    )));
     let drift = native_drift(&repository)?;
     if drift.0 == 0 {
         output.push_str("\n-> Found 0 faults\n");
@@ -160,6 +164,39 @@ fn required_value(arguments: &[String], index: usize, option: &str) -> Result<St
         .ok_or_else(|| format!("fensu init: error: argument {option}: expected one argument"))
 }
 
+fn existing_configuration(
+    repository: &Path,
+    path: &Path,
+    options: &InitOptions,
+) -> Result<CliOutput, String> {
+    if let Err(error) = load::load(repository) {
+        return Err(format!(
+            "Fensu configuration already exists but is not usable: {}\n{error}\nEdit that file, \
+             or delete it and rerun fensu init.",
+            path.display()
+        ));
+    }
+    if requests_scopes(options) {
+        return Err(format!(
+            "Fensu configuration already exists: {}\nRefusing to overwrite it, so --root, \
+             --tests, --tooling, and --name were not applied. Edit that file, or delete it and \
+             rerun fensu init.",
+            path.display()
+        ));
+    }
+    Ok(CliOutput::success(format!(
+        "Fensu configuration already exists: {} (nothing to do)\n",
+        path.display()
+    )))
+}
+
+fn requests_scopes(options: &InitOptions) -> bool {
+    !options.roots.is_empty()
+        || !options.tests.is_empty()
+        || !options.tooling.is_empty()
+        || options.name.is_some()
+}
+
 fn local_config(repository: &Path) -> Option<PathBuf> {
     let fensu = repository.join("fensu.toml");
     if fensu.is_file() {
@@ -191,7 +228,7 @@ fn repository_python_files(repository: &Path) -> Vec<PathBuf> {
 }
 
 fn detected_roots(repository: &Path) -> Vec<String> {
-    let mut roots = BTreeSet::new();
+    let mut candidates = BTreeSet::new();
     for path in repository_python_files(repository) {
         if path.file_name().and_then(|value| value.to_str()) != Some("__init__.py") {
             continue;
@@ -204,11 +241,24 @@ fn detected_roots(repository: &Path) -> Vec<String> {
             .is_some_and(|candidate| candidate.join("__init__.py").is_file());
         if !parent_parent_is_package {
             if let Ok(relative) = parent.strip_prefix(repository) {
-                roots.insert(relative.to_string_lossy().replace('\\', "/"));
+                candidates.insert(relative.to_string_lossy().replace('\\', "/"));
             }
         }
     }
-    roots.into_iter().collect()
+    let detected = candidates.into_iter().collect::<Vec<_>>();
+    detected
+        .iter()
+        .filter(|candidate| {
+            !detected
+                .iter()
+                .any(|ancestor| is_nested_within(candidate, ancestor))
+        })
+        .cloned()
+        .collect()
+}
+
+fn is_nested_within(candidate: &str, ancestor: &str) -> bool {
+    candidate.len() > ancestor.len() && candidate.starts_with(&format!("{ancestor}/"))
 }
 
 fn normalize_name(value: &str) -> Result<String, String> {
@@ -241,6 +291,12 @@ fn write_config(
     tests: &[String],
     tooling: &[String],
 ) -> Result<(), String> {
+    let text = config_text(roots, tests, tooling)?;
+    validate_config_text(&text)?;
+    fs::write(repository.join("fensu.toml"), text).map_err(|error| error.to_string())
+}
+
+fn config_text(roots: &[String], tests: &[String], tooling: &[String]) -> Result<String, String> {
     let mut text = format!(
         "roots = {}\ntests = {}\n",
         serde_json::to_string(roots).map_err(|error| error.to_string())?,
@@ -253,7 +309,16 @@ fn write_config(
         ));
     }
     text.push_str("select = [\"FF\"]\n");
-    fs::write(repository.join("fensu.toml"), text).map_err(|error| error.to_string())
+    Ok(text)
+}
+
+fn validate_config_text(text: &str) -> Result<(), String> {
+    validate_document(text).map_err(|error| {
+        format!(
+            "{error}\nRefusing to write fensu.toml. Choose the scopes explicitly, for example: \
+             fensu init --yes --root src/<package>"
+        )
+    })
 }
 
 fn write_gitignore(repository: &Path, empty: bool) -> Result<(), String> {
@@ -288,7 +353,7 @@ fn python_count(path: &Path) -> usize {
 fn native_drift(repository: &Path) -> Result<(usize, usize), String> {
     let invocation = env::current_dir().map_err(|error| error.to_string())?;
     env::set_current_dir(repository).map_err(|error| error.to_string())?;
-    let result = crate::helpers::check_execution::execute_check(&[
+    let result = crate::helpers::check::execution::execute_check(&[
         "--no-color".to_owned(),
         "--cache".to_owned(),
     ]);

fensu_cli-0.6.0/crates/fensu-cli/src/helpers/mod.rs

@@ -0,0 +1,5 @@
+pub(crate) mod catalogue;
+pub(crate) mod check;
+pub(crate) mod hosting;
+pub(crate) mod init;
+pub(crate) mod reporting;

fensu_cli-0.6.0/crates/fensu-cli/src/helpers/reporting/mod.rs

@@ -0,0 +1 @@
+pub(crate) mod render;

{fensu_cli-0.5.0 → fensu_cli-0.6.0}/crates/fensu-cli/src/mapping/helpers/index.rs

@@ -7,7 +7,7 @@ use fensu_facts::facts::mapping::models::{
 use fensu_facts::parsing::main::parse_strict::parse_strict;
 use fensu_facts::positions::main::index_lines::index_lines;
 
-use crate::helpers::check_policy::python_version;
+use crate::helpers::check::policy::python_version;
 use crate::mapping::constants::{
     EXPRESSION_ATTRIBUTE, EXPRESSION_NAME, EXPRESSION_SUBSCRIPT, INIT_MODULE_FILE,
 };

{fensu_cli-0.5.0 → fensu_cli-0.6.0}/crates/fensu-cli/src/models.rs

@@ -51,11 +51,11 @@ pub(crate) struct RuleMetadata {
     pub(crate) severity: String,
     pub(crate) enabled_by_default: bool,
     pub(crate) execution_owner: String,
-    #[serde(default = "crate::helpers::rule::core_kind")]
+    #[serde(default = "crate::helpers::catalogue::metadata::core_kind")]
     pub(crate) kind: String,
     #[serde(default)]
     pub(crate) source: Option<String>,
-    #[serde(default = "crate::helpers::rule::cacheable_default")]
+    #[serde(default = "crate::helpers::catalogue::metadata::cacheable_default")]
     pub(crate) cacheable: bool,
     #[serde(default)]
     pub(crate) options: Vec<RuleOptionMetadata>,

{fensu_cli-0.5.0 → fensu_cli-0.6.0}/crates/fensu-cli/src/skills/helpers/content/rendering.rs

@@ -221,7 +221,7 @@ fn configured_threshold_lines(context: &SkillContext) -> Result<Vec<String>, Str
         .chain(&context.warnings)
         .map(|rule| rule.code.clone())
         .collect::<Vec<_>>();
-    let required = crate::helpers::check_policy::required_thresholds(&active);
+    let required = crate::helpers::check::policy::required_thresholds(&active);
     let applicable = context
         .config
         .threshold_overrides

{fensu_cli-0.5.0 → fensu_cli-0.6.0}/crates/fensu-cli/src/skills/helpers/context/exceptions.rs

@@ -6,7 +6,7 @@ use fensu_facts::parsing::main::parse_strict::parse_strict;
 use ruff_python_ast::visitor::{walk_stmt, Visitor};
 use ruff_python_ast::Stmt;
 
-use crate::helpers::check_policy::python_version;
+use crate::helpers::check::policy::python_version;
 use crate::models::{Config, RuleMetadata};
 
 pub(crate) fn validate(

{fensu_cli-0.5.0 → fensu_cli-0.6.0}/crates/fensu-cli/src/skills/helpers/context/selection.rs

@@ -3,7 +3,8 @@ use std::path::Path;
 
 use serde_json::json;
 
-use crate::helpers::{process, rule};
+use crate::helpers::catalogue::metadata;
+use crate::helpers::hosting::process;
 use crate::models::{Config, RuleMetadata};
 use crate::skills::helpers::context::option_validation::validate_rule_options;
 use crate::skills::models::{HostResponse, RuleSelection};
@@ -40,7 +41,7 @@ pub(crate) fn selection(config: &Config, project_root: &Path) -> Result<RuleSele
     {
         return hosted_selection(project_root);
     }
-    let catalogue = rule::catalogue().to_vec();
+    let catalogue = metadata::catalogue().to_vec();
     let ignored = matching(&catalogue, &config.ignore);
     let ignored_codes = ignored
         .iter()

{fensu_cli-0.5.0 → fensu_cli-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "fensu-cli"
-version = "0.5.0" # x-release-please-version
+version = "0.6.0" # x-release-please-version
 description = "Native command-line executable for fensu"
 readme = "README.md"
 requires-python = ">=3.12"

fensu_cli-0.5.0/crates/fensu-cli/src/helpers/mod.rs

@@ -1,10 +0,0 @@
-pub(crate) mod cache;
-pub(crate) mod check_cleanup;
-pub(crate) mod check_evaluation;
-pub(crate) mod check_execution;
-pub(crate) mod check_policy;
-pub(crate) mod check_project;
-pub(crate) mod init;
-pub(crate) mod process;
-pub(crate) mod render;
-pub(crate) mod rule;