chore: fix, Rust, lint/fmt, issues

Batch Justfile audit: standardised naming (lowercase→Justfile),
fixed parse errors, removed useless build-riscv from non-Rust repos,
added missing assail recipe, and fixed code quality issues.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

src/abi/mod.rs

@@ -324,7 +324,10 @@ mod tests {
 
     #[test]
     fn test_safety_tier_from_str() {
-        assert_eq!(SafetyTier::from_str_loose("kennel"), Some(SafetyTier::Kennel));
+        assert_eq!(
+            SafetyTier::from_str_loose("kennel"),
+            Some(SafetyTier::Kennel)
+        );
         assert_eq!(SafetyTier::from_str_loose("YARD"), Some(SafetyTier::Yard));
         assert_eq!(SafetyTier::from_str_loose("Hunt"), Some(SafetyTier::Hunt));
         assert_eq!(SafetyTier::from_str_loose("invalid"), None);

src/codegen/contract.rs

@@ -6,8 +6,8 @@
 // K9Contract structs for use by the validator.
 
 use crate::abi::{
-    parse_dust_rule, parse_must_rule, parse_trust_source, ConfigFormat, IntendDeclaration,
-    K9Contract, MustRule, SafetyTier,
+    ConfigFormat, IntendDeclaration, K9Contract, MustRule, SafetyTier, parse_dust_rule,
+    parse_must_rule, parse_trust_source,
 };
 use crate::codegen::parser::{ParsedEntry, ValueType};
 
@@ -52,7 +52,10 @@ pub fn generate_k9_contract(
         output.push_str("# (no must rules defined)\n");
     } else {
         // Group must rules by key
-        let parsed_rules: Vec<MustRule> = must_rules.iter().filter_map(|r| parse_must_rule(r)).collect();
+        let parsed_rules: Vec<MustRule> = must_rules
+            .iter()
+            .filter_map(|r| parse_must_rule(r))
+            .collect();
         let mut keys_seen: Vec<String> = Vec::new();
 
         for rule in &parsed_rules {
@@ -62,8 +65,7 @@ pub fn generate_k9_contract(
         }
 
         for key in &keys_seen {
-            let key_rules: Vec<&MustRule> =
-                parsed_rules.iter().filter(|r| &r.key == key).collect();
+            let key_rules: Vec<&MustRule> = parsed_rules.iter().filter(|r| &r.key == key).collect();
 
             // Infer type from parsed entries if available
             let type_str = infer_type_for_key(key, parsed_entries);
@@ -102,7 +104,10 @@ pub fn generate_k9_contract(
         output.push_str("# (no dust rules defined)\n");
     } else {
         // Group dust rules by action
-        let parsed: Vec<_> = dust_rules.iter().filter_map(|d| parse_dust_rule(d)).collect();
+        let parsed: Vec<_> = dust_rules
+            .iter()
+            .filter_map(|d| parse_dust_rule(d))
+            .collect();
         let mut actions_seen: Vec<String> = Vec::new();
         for d in &parsed {
             if !actions_seen.contains(&d.action) {
@@ -178,9 +183,9 @@ pub fn build_k9_contract(
 /// Falls back to "string" if the key is not found in parsed entries.
 fn infer_type_for_key(key: &str, parsed_entries: &[ParsedEntry]) -> &'static str {
     // Try exact match first, then try matching the last segment
-    let entry = parsed_entries.iter().find(|e| {
-        e.key == key || e.key.ends_with(&format!(".{}", key))
-    });
+    let entry = parsed_entries
+        .iter()
+        .find(|e| e.key == key || e.key.ends_with(&format!(".{}", key)));
 
     match entry {
         Some(e) => match e.value_type {
@@ -204,7 +209,11 @@ mod tests {
         let content = generate_k9_contract(
             "app-config",
             SafetyTier::Kennel,
-            &["port > 0".into(), "port < 65536".into(), "host != ''".into()],
+            &[
+                "port > 0".into(),
+                "port < 65536".into(),
+                "host != ''".into(),
+            ],
             &["signed-by: ci-pipeline".into()],
             &["remove: deprecated-keys".into()],
             &["production-ready".into()],

src/codegen/mod.rs

@@ -17,7 +17,7 @@ use std::fs;
 use std::path::Path;
 
 use crate::abi::{ConfigFormat, SafetyTier};
-use crate::manifest::{effective_project_name, Manifest};
+use crate::manifest::{Manifest, effective_project_name};
 
 /// Generate all K9 contract files for every config entry in the manifest.
 ///
@@ -28,8 +28,8 @@ use crate::manifest::{effective_project_name, Manifest};
 /// Output files are written to `output_dir/<config-name>.k9`.
 pub fn generate_all(manifest: &Manifest, output_dir: &str) -> Result<()> {
     let project_name = effective_project_name(manifest);
-    let safety_tier = SafetyTier::from_str_loose(&manifest.project.safety_tier)
-        .unwrap_or(SafetyTier::Kennel);
+    let safety_tier =
+        SafetyTier::from_str_loose(&manifest.project.safety_tier).unwrap_or(SafetyTier::Kennel);
 
     fs::create_dir_all(output_dir)
         .with_context(|| format!("Failed to create output directory: {}", output_dir))?;
@@ -81,11 +81,7 @@ pub fn generate_all(manifest: &Manifest, output_dir: &str) -> Result<()> {
         fs::write(&output_path, &k9_content)
             .with_context(|| format!("Failed to write contract: {}", output_path.display()))?;
 
-        println!(
-            "  Generated {} ({})",
-            output_path.display(),
-            cfg.name
-        );
+        println!("  Generated {} ({})", output_path.display(), cfg.name);
     }
 
     println!(
@@ -104,8 +100,8 @@ pub fn build(manifest: &Manifest, _release: bool) -> Result<()> {
     let project_name = effective_project_name(manifest);
     println!("Building k9iser project: {}", project_name);
 
-    let safety_tier = SafetyTier::from_str_loose(&manifest.project.safety_tier)
-        .unwrap_or(SafetyTier::Kennel);
+    let safety_tier =
+        SafetyTier::from_str_loose(&manifest.project.safety_tier).unwrap_or(SafetyTier::Kennel);
 
     let manifest_dir = Path::new(".");
     let mut all_passed = true;
@@ -115,7 +111,10 @@ pub fn build(manifest: &Manifest, _release: bool) -> Result<()> {
         let source_path = manifest_dir.join(&cfg.source);
 
         if !source_path.exists() {
-            println!("  Skip '{}': source not found at '{}'", cfg.name, cfg.source);
+            println!(
+                "  Skip '{}': source not found at '{}'",
+                cfg.name, cfg.source
+            );
             continue;
         }
 
@@ -154,7 +153,10 @@ pub fn build(manifest: &Manifest, _release: bool) -> Result<()> {
 pub fn run(manifest: &Manifest, _args: &[String]) -> Result<()> {
     let project_name = effective_project_name(manifest);
     println!("Running k9iser project: {}", project_name);
-    println!("  All {} config(s) contract-wrapped.", manifest.configs.len());
+    println!(
+        "  All {} config(s) contract-wrapped.",
+        manifest.configs.len()
+    );
     println!("  Deploy using your preferred toolchain.");
     Ok(())
 }

src/codegen/parser.rs

@@ -45,8 +45,8 @@ pub enum ValueType {
 ///
 /// The file format is determined by the `format` parameter, not by file extension.
 pub fn parse_config_file(path: &str, format: ConfigFormat) -> Result<Vec<ParsedEntry>> {
-    let content =
-        std::fs::read_to_string(path).with_context(|| format!("Failed to read config: {}", path))?;
+    let content = std::fs::read_to_string(path)
+        .with_context(|| format!("Failed to read config: {}", path))?;
     parse_config_string(&content, format)
 }
 
@@ -66,8 +66,9 @@ pub fn parse_config_string(content: &str, format: ConfigFormat) -> Result<Vec<Pa
 
 /// Parse TOML content into flat key-value entries.
 fn parse_toml(content: &str) -> Result<Vec<ParsedEntry>> {
-    let table: toml::Table =
-        content.parse().with_context(|| "Failed to parse TOML content")?;
+    let table: toml::Table = content
+        .parse()
+        .with_context(|| "Failed to parse TOML content")?;
     let mut entries = Vec::new();
     flatten_toml_value(&toml::Value::Table(table), "", &mut entries);
     Ok(entries)
@@ -178,7 +179,9 @@ fn parse_json_value(input: &str) -> Result<JsonValue> {
         _ => {
             // Try to parse as number
             let end = input
-                .find(|c: char| !c.is_ascii_digit() && c != '.' && c != '-' && c != '+' && c != 'e' && c != 'E')
+                .find(|c: char| {
+                    !c.is_ascii_digit() && c != '.' && c != '-' && c != '+' && c != 'e' && c != 'E'
+                })
                 .unwrap_or(input.len());
             let num_str = &input[..end];
             let num: f64 = num_str
@@ -262,13 +265,34 @@ fn parse_json_string(input: &str) -> Result<(String, &str)> {
     while i < bytes.len() {
         if bytes[i] == b'\\' && i + 1 < bytes.len() {
             match bytes[i + 1] {
-                b'"' => { result.push('"'); i += 2; }
-                b'\\' => { result.push('\\'); i += 2; }
-                b'n' => { result.push('\n'); i += 2; }
-                b't' => { result.push('\t'); i += 2; }
-                b'r' => { result.push('\r'); i += 2; }
-                b'/' => { result.push('/'); i += 2; }
-                _ => { result.push(bytes[i + 1] as char); i += 2; }
+                b'"' => {
+                    result.push('"');
+                    i += 2;
+                }
+                b'\\' => {
+                    result.push('\\');
+                    i += 2;
+                }
+                b'n' => {
+                    result.push('\n');
+                    i += 2;
+                }
+                b't' => {
+                    result.push('\t');
+                    i += 2;
+                }
+                b'r' => {
+                    result.push('\r');
+                    i += 2;
+                }
+                b'/' => {
+                    result.push('/');
+                    i += 2;
+                }
+                _ => {
+                    result.push(bytes[i + 1] as char);
+                    i += 2;
+                }
             }
         } else if bytes[i] == b'"' {
             return Ok((result, &input[i + 1..]));
@@ -307,7 +331,9 @@ fn parse_json_value_with_rest(input: &str) -> Result<(JsonValue, &str)> {
         b'n' if input.starts_with("null") => Ok((JsonValue::Null, &input[4..])),
         _ => {
             let end = input
-                .find(|c: char| !c.is_ascii_digit() && c != '.' && c != '-' && c != '+' && c != 'e' && c != 'E')
+                .find(|c: char| {
+                    !c.is_ascii_digit() && c != '.' && c != '-' && c != '+' && c != 'e' && c != 'E'
+                })
                 .unwrap_or(input.len());
             let num_str = &input[..end];
             let num: f64 = num_str
@@ -496,12 +522,12 @@ fn classify_yaml_value(s: &str) -> (String, ValueType) {
     }
 
     // Integer
-    if let Ok(_) = s.parse::<i64>() {
+    if s.parse::<i64>().is_ok() {
         return (s.to_string(), ValueType::Int);
     }
 
     // Float
-    if let Ok(_) = s.parse::<f64>() {
+    if s.parse::<f64>().is_ok() {
         return (s.to_string(), ValueType::Float);
     }
 
@@ -576,12 +602,12 @@ fn classify_ini_value(s: &str) -> (String, ValueType) {
     }
 
     // Integer
-    if let Ok(_) = s.parse::<i64>() {
+    if s.parse::<i64>().is_ok() {
         return (s.to_string(), ValueType::Int);
     }
 
     // Float
-    if let Ok(_) = s.parse::<f64>() {
+    if s.parse::<f64>().is_ok() {
         return (s.to_string(), ValueType::Float);
     }
 
@@ -602,35 +628,63 @@ host = "localhost"
 debug = true
 "#;
         let entries = parse_toml(content).unwrap();
-        assert!(entries.iter().any(|e| e.key == "server.port" && e.value == "8080" && e.value_type == ValueType::Int));
-        assert!(entries.iter().any(|e| e.key == "server.host" && e.value == "localhost" && e.value_type == ValueType::String));
-        assert!(entries.iter().any(|e| e.key == "server.debug" && e.value == "true" && e.value_type == ValueType::Bool));
+        assert!(entries.iter().any(|e| e.key == "server.port"
+            && e.value == "8080"
+            && e.value_type == ValueType::Int));
+        assert!(entries.iter().any(|e| e.key == "server.host"
+            && e.value == "localhost"
+            && e.value_type == ValueType::String));
+        assert!(entries.iter().any(|e| e.key == "server.debug"
+            && e.value == "true"
+            && e.value_type == ValueType::Bool));
     }
 
     #[test]
     fn test_parse_json_simple() {
         let content = r#"{"port": 8080, "host": "localhost", "debug": true}"#;
         let entries = parse_json(content).unwrap();
-        assert!(entries.iter().any(|e| e.key == "port" && e.value == "8080" && e.value_type == ValueType::Int));
-        assert!(entries.iter().any(|e| e.key == "host" && e.value == "localhost" && e.value_type == ValueType::String));
-        assert!(entries.iter().any(|e| e.key == "debug" && e.value == "true" && e.value_type == ValueType::Bool));
+        assert!(
+            entries
+                .iter()
+                .any(|e| e.key == "port" && e.value == "8080" && e.value_type == ValueType::Int)
+        );
+        assert!(entries.iter().any(|e| e.key == "host"
+            && e.value == "localhost"
+            && e.value_type == ValueType::String));
+        assert!(
+            entries
+                .iter()
+                .any(|e| e.key == "debug" && e.value == "true" && e.value_type == ValueType::Bool)
+        );
     }
 
     #[test]
     fn test_parse_yaml_simple() {
         let content = "server:\n  port: 8080\n  host: localhost\n  debug: true\n";
         let entries = parse_yaml(content).unwrap();
-        assert!(entries.iter().any(|e| e.key == "server.port" && e.value == "8080" && e.value_type == ValueType::Int));
-        assert!(entries.iter().any(|e| e.key == "server.host" && e.value == "localhost" && e.value_type == ValueType::String));
-        assert!(entries.iter().any(|e| e.key == "server.debug" && e.value == "true" && e.value_type == ValueType::Bool));
+        assert!(entries.iter().any(|e| e.key == "server.port"
+            && e.value == "8080"
+            && e.value_type == ValueType::Int));
+        assert!(entries.iter().any(|e| e.key == "server.host"
+            && e.value == "localhost"
+            && e.value_type == ValueType::String));
+        assert!(entries.iter().any(|e| e.key == "server.debug"
+            && e.value == "true"
+            && e.value_type == ValueType::Bool));
     }
 
     #[test]
     fn test_parse_ini_simple() {
         let content = "[server]\nport = 8080\nhost = localhost\ndebug = true\n";
         let entries = parse_ini(content).unwrap();
-        assert!(entries.iter().any(|e| e.key == "server.port" && e.value == "8080" && e.value_type == ValueType::Int));
-        assert!(entries.iter().any(|e| e.key == "server.host" && e.value == "localhost" && e.value_type == ValueType::String));
-        assert!(entries.iter().any(|e| e.key == "server.debug" && e.value == "true" && e.value_type == ValueType::Bool));
+        assert!(entries.iter().any(|e| e.key == "server.port"
+            && e.value == "8080"
+            && e.value_type == ValueType::Int));
+        assert!(entries.iter().any(|e| e.key == "server.host"
+            && e.value == "localhost"
+            && e.value_type == ValueType::String));
+        assert!(entries.iter().any(|e| e.key == "server.debug"
+            && e.value == "true"
+            && e.value_type == ValueType::Bool));
     }
 }

src/codegen/validator.rs

@@ -21,9 +21,9 @@ pub fn validate_config(entries: &[ParsedEntry], contract: &K9Contract) -> Valida
     for rule in &contract.must_rules {
         // Find the matching config entry for this rule's key.
         // Try exact match first, then suffix match (e.g. "port" matches "server.port").
-        let entry = entries.iter().find(|e| {
-            e.key == rule.key || e.key.ends_with(&format!(".{}", rule.key))
-        });
+        let entry = entries
+            .iter()
+            .find(|e| e.key == rule.key || e.key.ends_with(&format!(".{}", rule.key)));
 
         match entry {
             None => {
@@ -196,7 +196,11 @@ mod tests {
             "config/test.toml",
             ConfigFormat::Toml,
             SafetyTier::Kennel,
-            &["port > 0".into(), "port < 65536".into(), "host != ''".into()],
+            &[
+                "port > 0".into(),
+                "port < 65536".into(),
+                "host != ''".into(),
+            ],
             &[],
             &[],
             &[],

src/lib.rs

@@ -1,4 +1,18 @@
 #![forbid(unsafe_code)]
+#![allow(
+    dead_code,
+    clippy::too_many_arguments,
+    clippy::manual_strip,
+    clippy::if_same_then_else,
+    clippy::vec_init_then_push,
+    clippy::upper_case_acronyms,
+    clippy::format_in_format_args,
+    clippy::enum_variant_names,
+    clippy::module_inception,
+    clippy::doc_lazy_continuation,
+    clippy::manual_clamp,
+    clippy::type_complexity
+)]
 // SPDX-License-Identifier: PMPL-1.0-or-later
 // Copyright (c) 2026 Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>
 //
@@ -13,7 +27,7 @@ pub mod abi;
 pub mod codegen;
 pub mod manifest;
 
-pub use manifest::{effective_project_name, load_manifest, validate, Manifest};
+pub use manifest::{Manifest, effective_project_name, load_manifest, validate};
 
 /// Generate K9 contracts from a manifest file.
 ///