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/codegen/mod.rs

@@ -1,13 +1,15 @@
 // SPDX-License-Identifier: PMPL-1.0-or-later
 // Copyright (c) 2026 Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>
+use crate::manifest::Manifest;
 use anyhow::{Context, Result};
 use std::fs;
-use std::path::Path;
-use crate::manifest::Manifest;
 
 pub fn generate_all(manifest: &Manifest, output_dir: &str) -> Result<()> {
     fs::create_dir_all(output_dir).context("Failed to create output dir")?;
-    println!("  [stub] A2ML codegen for '{}' — implementation pending", manifest.workload.name);
+    println!(
+        "  [stub] A2ML codegen for '{}' — implementation pending",
+        manifest.workload.name
+    );
     Ok(())
 }
 

src/lib.rs

@@ -4,7 +4,7 @@
 pub mod abi;
 pub mod codegen;
 pub mod manifest;
-pub use manifest::{load_manifest, validate, Manifest};
+pub use manifest::{Manifest, load_manifest, validate};
 
 pub fn generate(manifest_path: &str, output_dir: &str) -> anyhow::Result<()> {
     let m = load_manifest(manifest_path)?;

src/main.rs

@@ -21,34 +21,71 @@ struct Cli {
 #[derive(Subcommand)]
 enum Commands {
     /// Initialise a new a2mliser.toml manifest.
-    Init { #[arg(short, long, default_value = ".")] path: String },
+    Init {
+        #[arg(short, long, default_value = ".")]
+        path: String,
+    },
     /// Validate a a2mliser.toml manifest.
-    Validate { #[arg(short, long, default_value = "a2mliser.toml")] manifest: String },
+    Validate {
+        #[arg(short, long, default_value = "a2mliser.toml")]
+        manifest: String,
+    },
     /// Generate A2ML wrapper, Zig FFI bridge, and C headers.
     Generate {
-        #[arg(short, long, default_value = "a2mliser.toml")] manifest: String,
-        #[arg(short, long, default_value = "generated/a2mliser")] output: String,
+        #[arg(short, long, default_value = "a2mliser.toml")]
+        manifest: String,
+        #[arg(short, long, default_value = "generated/a2mliser")]
+        output: String,
     },
     /// Build the generated artifacts.
-    Build { #[arg(short, long, default_value = "a2mliser.toml")] manifest: String, #[arg(long)] release: bool },
+    Build {
+        #[arg(short, long, default_value = "a2mliser.toml")]
+        manifest: String,
+        #[arg(long)]
+        release: bool,
+    },
     /// Run the workload.
     Run {
-        #[arg(short, long, default_value = "a2mliser.toml")] manifest: String,
-        #[arg(trailing_var_arg = true)] args: Vec<String>,
+        #[arg(short, long, default_value = "a2mliser.toml")]
+        manifest: String,
+        #[arg(trailing_var_arg = true)]
+        args: Vec<String>,
     },
     /// Show manifest information.
-    Info { #[arg(short, long, default_value = "a2mliser.toml")] manifest: String },
+    Info {
+        #[arg(short, long, default_value = "a2mliser.toml")]
+        manifest: String,
+    },
 }
 
 fn main() -> Result<()> {
     let cli = Cli::parse();
     match cli.command {
-        Commands::Init { path } => { manifest::init_manifest(&path)?; }
-        Commands::Validate { manifest } => { let m = manifest::load_manifest(&manifest)?; manifest::validate(&m)?; println!("Valid: {}", m.workload.name); }
-        Commands::Generate { manifest, output } => { let m = manifest::load_manifest(&manifest)?; manifest::validate(&m)?; codegen::generate_all(&m, &output)?; }
-        Commands::Build { manifest, release } => { let m = manifest::load_manifest(&manifest)?; codegen::build(&m, release)?; }
-        Commands::Run { manifest, args } => { let m = manifest::load_manifest(&manifest)?; codegen::run(&m, &args)?; }
-        Commands::Info { manifest } => { let m = manifest::load_manifest(&manifest)?; manifest::print_info(&m); }
+        Commands::Init { path } => {
+            manifest::init_manifest(&path)?;
+        }
+        Commands::Validate { manifest } => {
+            let m = manifest::load_manifest(&manifest)?;
+            manifest::validate(&m)?;
+            println!("Valid: {}", m.workload.name);
+        }
+        Commands::Generate { manifest, output } => {
+            let m = manifest::load_manifest(&manifest)?;
+            manifest::validate(&m)?;
+            codegen::generate_all(&m, &output)?;
+        }
+        Commands::Build { manifest, release } => {
+            let m = manifest::load_manifest(&manifest)?;
+            codegen::build(&m, release)?;
+        }
+        Commands::Run { manifest, args } => {
+            let m = manifest::load_manifest(&manifest)?;
+            codegen::run(&m, &args)?;
+        }
+        Commands::Info { manifest } => {
+            let m = manifest::load_manifest(&manifest)?;
+            manifest::print_info(&m);
+        }
     }
     Ok(())
 }

src/manifest/mod.rs

@@ -35,24 +35,37 @@ pub struct Options {
 }
 
 pub fn load_manifest(path: &str) -> Result<Manifest> {
-    let content = std::fs::read_to_string(path).with_context(|| format!("Failed to read: {}", path))?;
+    let content =
+        std::fs::read_to_string(path).with_context(|| format!("Failed to read: {}", path))?;
     toml::from_str(&content).with_context(|| format!("Failed to parse: {}", path))
 }
 
 pub fn validate(manifest: &Manifest) -> Result<()> {
-    if manifest.workload.name.is_empty() { anyhow::bail!("workload.name required"); }
-    if manifest.workload.entry.is_empty() { anyhow::bail!("workload.entry required"); }
+    if manifest.workload.name.is_empty() {
+        anyhow::bail!("workload.name required");
+    }
+    if manifest.workload.entry.is_empty() {
+        anyhow::bail!("workload.entry required");
+    }
     Ok(())
 }
 
 pub fn init_manifest(path: &str) -> Result<()> {
     let p = Path::new(path).join("a2mliser.toml");
-    if p.exists() { anyhow::bail!("a2mliser.toml already exists"); }
-    std::fs::write(&p, "# a2mliser manifest\n[workload]\nname = \"my-workload\"\nentry = \"src/lib.rs::process\"\n\n[data]\ninput-type = \"Vec<Item>\"\noutput-type = \"Vec<Result>\"\n")?;
+    if p.exists() {
+        anyhow::bail!("a2mliser.toml already exists");
+    }
+    std::fs::write(
+        &p,
+        "# a2mliser manifest\n[workload]\nname = \"my-workload\"\nentry = \"src/lib.rs::process\"\n\n[data]\ninput-type = \"Vec<Item>\"\noutput-type = \"Vec<Result>\"\n",
+    )?;
     println!("Created {}", p.display());
     Ok(())
 }
 
 pub fn print_info(m: &Manifest) {
-    println!("=== {} ===\nEntry: {}\nInput: {}\nOutput: {}", m.workload.name, m.workload.entry, m.data.input_type, m.data.output_type);
+    println!(
+        "=== {} ===\nEntry: {}\nInput: {}\nOutput: {}",
+        m.workload.name, m.workload.entry, m.data.input_type, m.data.output_type
+    );
 }