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

@@ -232,7 +232,11 @@ impl GeneratedRepo {
     /// Check that the repo contains the mandatory artifact categories
     /// (mirrors the Idris2 `GenerationComplete` proof).
     pub fn is_complete(&self) -> bool {
-        let paths: Vec<String> = self.files.iter().map(|f| f.path.display().to_string()).collect();
+        let paths: Vec<String> = self
+            .files
+            .iter()
+            .map(|f| f.path.display().to_string())
+            .collect();
         let has = |needle: &str| paths.iter().any(|p| p.contains(needle));
 
         has("Cargo.toml")

src/codegen/customizer.rs

@@ -360,7 +360,11 @@ mod tests {
     use super::*;
     use crate::abi::*;
 
-    fn make_model(paradigm: Paradigm, target: CompilationTarget, type_sys: TypeSystemFeature) -> LanguageModel {
+    fn make_model(
+        paradigm: Paradigm,
+        target: CompilationTarget,
+        type_sys: TypeSystemFeature,
+    ) -> LanguageModel {
         LanguageModel {
             name: "TestLang".to_string(),
             paradigm,
@@ -372,39 +376,75 @@ mod tests {
 
     #[test]
     fn test_functional_adds_adt_mapper() {
-        let model = make_model(Paradigm::Functional, CompilationTarget::Native, TypeSystemFeature::Algebraic);
+        let model = make_model(
+            Paradigm::Functional,
+            CompilationTarget::Native,
+            TypeSystemFeature::Algebraic,
+        );
         let mut files = Vec::new();
         apply_customizations(&model, &mut files);
-        assert!(files.iter().any(|f| f.path.to_str().unwrap().contains("adt_mapper")));
+        assert!(
+            files
+                .iter()
+                .any(|f| f.path.to_str().unwrap().contains("adt_mapper"))
+        );
     }
 
     #[test]
     fn test_array_adds_array_bridge() {
-        let model = make_model(Paradigm::Array, CompilationTarget::Native, TypeSystemFeature::ArrayTypes);
+        let model = make_model(
+            Paradigm::Array,
+            CompilationTarget::Native,
+            TypeSystemFeature::ArrayTypes,
+        );
         let mut files = Vec::new();
         apply_customizations(&model, &mut files);
-        assert!(files.iter().any(|f| f.path.to_str().unwrap().contains("array_bridge")));
+        assert!(
+            files
+                .iter()
+                .any(|f| f.path.to_str().unwrap().contains("array_bridge"))
+        );
     }
 
     #[test]
     fn test_beam_adds_nif_boilerplate() {
-        let model = make_model(Paradigm::Functional, CompilationTarget::Beam, TypeSystemFeature::Algebraic);
+        let model = make_model(
+            Paradigm::Functional,
+            CompilationTarget::Beam,
+            TypeSystemFeature::Algebraic,
+        );
         let mut files = Vec::new();
         apply_customizations(&model, &mut files);
-        assert!(files.iter().any(|f| f.path.to_str().unwrap().contains("beam_nif")));
+        assert!(
+            files
+                .iter()
+                .any(|f| f.path.to_str().unwrap().contains("beam_nif"))
+        );
     }
 
     #[test]
     fn test_dependent_types_add_deep_proof_docs() {
-        let model = make_model(Paradigm::Functional, CompilationTarget::Native, TypeSystemFeature::Dependent);
+        let model = make_model(
+            Paradigm::Functional,
+            CompilationTarget::Native,
+            TypeSystemFeature::Dependent,
+        );
         let mut files = Vec::new();
         apply_customizations(&model, &mut files);
-        assert!(files.iter().any(|f| f.path.to_str().unwrap().contains("deep-abi-proofs")));
+        assert!(
+            files
+                .iter()
+                .any(|f| f.path.to_str().unwrap().contains("deep-abi-proofs"))
+        );
     }
 
     #[test]
     fn test_imperative_native_minimal_extras() {
-        let model = make_model(Paradigm::Imperative, CompilationTarget::Native, TypeSystemFeature::Simple);
+        let model = make_model(
+            Paradigm::Imperative,
+            CompilationTarget::Native,
+            TypeSystemFeature::Simple,
+        );
         let mut files = Vec::new();
         apply_customizations(&model, &mut files);
         // Imperative + native + simple = no extras

src/codegen/parser.rs

@@ -32,10 +32,7 @@ pub enum ValidationError {
     /// A key primitive is invalid (empty or too long).
     InvalidPrimitive(String),
     /// The repo name does not match the expected derived name.
-    RepoNameMismatch {
-        expected: String,
-        actual: String,
-    },
+    RepoNameMismatch { expected: String, actual: String },
     /// The compilation target is unusual for the paradigm (warning-level).
     UnusualTarget {
         paradigm: Paradigm,
@@ -49,7 +46,10 @@ impl std::fmt::Display for ValidationError {
             ValidationError::InvalidLanguageName(name) => {
                 write!(f, "Invalid language name: '{}'", name)
             }
-            ValidationError::IncompatibleTypeSystem { paradigm, type_system } => {
+            ValidationError::IncompatibleTypeSystem {
+                paradigm,
+                type_system,
+            } => {
                 write!(
                     f,
                     "Type system '{}' is incompatible with paradigm '{}'",
@@ -110,7 +110,11 @@ pub fn validate_language_description(manifest: &Manifest) -> ValidationReport {
     // 1. Language name: must be non-empty, ASCII alphanumeric + hyphens
     if model.name.is_empty() {
         errors.push(ValidationError::InvalidLanguageName(model.name.clone()));
-    } else if !model.name.chars().all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '+') {
+    } else if !model
+        .name
+        .chars()
+        .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '+')
+    {
         errors.push(ValidationError::InvalidLanguageName(model.name.clone()));
     }
 
@@ -145,10 +149,7 @@ pub fn validate_language_description(manifest: &Manifest) -> ValidationReport {
 ///   - "logic" paradigm with "none" type system is technically valid
 ///     but unusual (most logic languages have types)
 ///   - "array" paradigm with "dependent" types is uncommon
-fn check_paradigm_type_compatibility(
-    model: &LanguageModel,
-    _errors: &mut Vec<ValidationError>,
-) {
+fn check_paradigm_type_compatibility(model: &LanguageModel, _errors: &mut Vec<ValidationError>) {
     // Currently all combinations are valid.  This function is a hook
     // for future constraints as the -iser ecosystem grows.
     // The Idris2 ABI proofs handle the hard constraints at compile time;
@@ -158,10 +159,7 @@ fn check_paradigm_type_compatibility(
 
 /// Check that the paradigm and target are consistent.
 /// Flags unusual but not impossible combinations as warnings.
-fn check_paradigm_target_consistency(
-    model: &LanguageModel,
-    warnings: &mut Vec<ValidationError>,
-) {
+fn check_paradigm_target_consistency(model: &LanguageModel, warnings: &mut Vec<ValidationError>) {
     // Logic languages on GPU is unusual
     if model.paradigm == Paradigm::Logic && model.compilation_target == CompilationTarget::Gpu {
         warnings.push(ValidationError::UnusualTarget {
@@ -184,7 +182,10 @@ pub fn validate_or_bail(manifest: &Manifest) -> Result<ValidationReport> {
     let report = validate_language_description(manifest);
     if !report.is_valid() {
         let msgs: Vec<String> = report.errors.iter().map(|e| e.to_string()).collect();
-        anyhow::bail!("Language description validation failed:\n  {}", msgs.join("\n  "));
+        anyhow::bail!(
+            "Language description validation failed:\n  {}",
+            msgs.join("\n  ")
+        );
     }
     Ok(report)
 }
@@ -281,6 +282,11 @@ description = "Prolog -iser"
         let m = parse_manifest(toml).unwrap();
         let report = validate_language_description(&m);
         assert!(report.is_valid());
-        assert!(report.warnings.iter().any(|w| matches!(w, ValidationError::UnusualTarget { .. })));
+        assert!(
+            report
+                .warnings
+                .iter()
+                .any(|w| matches!(w, ValidationError::UnusualTarget { .. }))
+        );
     }
 }

src/codegen/scaffold.rs

@@ -106,7 +106,11 @@ fn write_files(root: &Path, files: &[GeneratedFile]) -> Result<()> {
 // ---------------------------------------------------------------------------
 
 /// Generate `Cargo.toml` for the new -iser.
-fn generate_cargo_toml(manifest: &Manifest, model: &LanguageModel, iser_name: &str) -> GeneratedFile {
+fn generate_cargo_toml(
+    manifest: &Manifest,
+    model: &LanguageModel,
+    iser_name: &str,
+) -> GeneratedFile {
     let content = format!(
         r#"# SPDX-License-Identifier: PMPL-1.0-or-later
 [package]
@@ -1046,7 +1050,10 @@ fn idris2_module_name(model: &LanguageModel) -> String {
 /// E.g. "task" -> "TaskPrim", "forall" -> "ForallPrim".
 fn to_idris_constructor(prim: &str) -> String {
     let mut chars = prim.chars();
-    let first = chars.next().map(|c| c.to_uppercase().to_string()).unwrap_or_default();
+    let first = chars
+        .next()
+        .map(|c| c.to_uppercase().to_string())
+        .unwrap_or_default();
     format!("{}{}Prim", first, chars.as_str())
 }
 
@@ -1086,10 +1093,18 @@ description = "Chapel distributed computing -iser"
         let manifest = test_manifest();
         let tmp = tempfile::tempdir().unwrap();
         let result = scaffold_repo(&manifest, tmp.path());
-        assert!(result.is_success(), "scaffold failed: {:?}", result.error_message());
+        assert!(
+            result.is_success(),
+            "scaffold failed: {:?}",
+            result.error_message()
+        );
         let repo = result.repo().unwrap();
         assert_eq!(repo.name, "chapeliser");
-        assert!(repo.file_count() >= 20, "expected 20+ files, got {}", repo.file_count());
+        assert!(
+            repo.file_count() >= 20,
+            "expected 20+ files, got {}",
+            repo.file_count()
+        );
     }
 
     #[test]
@@ -1098,10 +1113,7 @@ description = "Chapel distributed computing -iser"
         let tmp = tempfile::tempdir().unwrap();
         let result = scaffold_repo(&manifest, tmp.path());
         let repo = result.repo().unwrap();
-        assert!(
-            repo.is_complete(),
-            "repo missing mandatory categories"
-        );
+        assert!(repo.is_complete(), "repo missing mandatory categories");
     }
 
     #[test]

src/lib.rs

@@ -1,4 +1,11 @@
 #![forbid(unsafe_code)]
+#![allow(
+    dead_code,
+    clippy::too_many_arguments,
+    clippy::manual_strip,
+    clippy::if_same_then_else,
+    clippy::vec_init_then_push
+)]
 // SPDX-License-Identifier: PMPL-1.0-or-later
 // Copyright (c) 2026 Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>
 //
@@ -18,7 +25,7 @@ pub use abi::{
     CompilationTarget, GeneratedFile, GeneratedRepo, LanguageModel, Paradigm, ScaffoldResult,
     TypeSystemFeature,
 };
-pub use manifest::{load_manifest, parse_manifest, validate, Manifest};
+pub use manifest::{Manifest, load_manifest, parse_manifest, validate};
 
 /// Convenience: load a manifest, validate, and generate a complete -iser repo.
 pub fn generate(manifest_path: &str, output_dir: &str) -> anyhow::Result<ScaffoldResult> {

src/main.rs

@@ -1,3 +1,10 @@
+#![allow(
+    dead_code,
+    clippy::too_many_arguments,
+    clippy::manual_strip,
+    clippy::if_same_then_else,
+    clippy::vec_init_then_push
+)]
 #![forbid(unsafe_code)]
 // SPDX-License-Identifier: PMPL-1.0-or-later
 // Copyright (c) 2026 Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>

src/manifest/mod.rs

@@ -117,8 +117,7 @@ impl Manifest {
 pub fn load_manifest(path: &str) -> Result<Manifest> {
     let content = std::fs::read_to_string(path)
         .with_context(|| format!("Failed to read manifest: {}", path))?;
-    parse_manifest(&content)
-        .with_context(|| format!("Failed to parse manifest: {}", path))
+    parse_manifest(&content).with_context(|| format!("Failed to parse manifest: {}", path))
 }
 
 /// Parse a manifest from a TOML string (useful for testing).
@@ -168,7 +167,10 @@ pub fn validate(manifest: &Manifest) -> Result<()> {
 pub fn init_manifest(path: &str) -> Result<()> {
     let manifest_path = Path::new(path).join("iseriser.toml");
     if manifest_path.exists() {
-        anyhow::bail!("iseriser.toml already exists at {}", manifest_path.display());
+        anyhow::bail!(
+            "iseriser.toml already exists at {}",
+            manifest_path.display()
+        );
     }
     let template = r#"# iseriser manifest — describe a target language to generate an -iser for.
 # SPDX-License-Identifier: PMPL-1.0-or-later