add wit command and improve template help

Author: Lochlan Wansbrough

src/app.rs

@@ -115,6 +115,7 @@ impl App {
             //     .await?
             // }
             // Some(CliCommand::Publish) => crate::commands::publish::publish().await?,
+            Some(CliCommand::Wit) => crate::commands::wit::wit().await?,
             Some(CliCommand::Upgrade) => crate::commands::upgrade::upgrade().await?,
             Some(CliCommand::Docs) => crate::commands::docs::docs(&self.config, &self.mode).await?,
             None => {}

src/cli.rs

@@ -1,9 +1,35 @@
 use std::path::PathBuf;
 
+use clap::builder::PossibleValuesParser;
 use clap::{Parser, Subcommand};
 
 use crate::utils::version;
 
+/// Distinct template names embedded under `src/templates/<category>/` (e.g.
+/// `game` -> `hello-rust`, `cube-python`, ...). Drives both `--help` listing and
+/// validation, so it always matches the templates actually shipped in the binary.
+fn template_names(category: &str) -> Vec<String> {
+    let prefix = format!("{category}/");
+    let mut names: Vec<String> = crate::assets::Templates::iter()
+        .filter_map(|p| {
+            p.strip_prefix(&prefix)
+                .and_then(|rest| rest.split('/').next())
+                .map(|name| name.to_string())
+        })
+        .collect();
+    names.sort();
+    names.dedup();
+    names
+}
+
+fn game_templates() -> PossibleValuesParser {
+    PossibleValuesParser::new(template_names("game"))
+}
+
+fn package_templates() -> PossibleValuesParser {
+    PossibleValuesParser::new(template_names("package"))
+}
+
 #[derive(Parser)]
 #[command(author, version = version(), about)]
 pub struct Cli {
@@ -88,6 +114,8 @@ pub enum CliCommand {
     //     #[clap(long, short = 'v', value_name = "VERSION")]
     //     version: Option<String>,
     // },
+    /// Re-sync the project's staged WIT to this CLI's embedded runtime definitions
+    Wit,
     /// Upgrade the Jumpjet CLI to the latest version
     Upgrade,
 }
@@ -100,17 +128,17 @@ pub enum NewSubcommand {
         identifier: Option<String>,
         #[clap(long, short = 'n', value_name = "NAME")]
         name: Option<String>,
-        /// One of: hello-js, hello-rust, cube-rust
-        #[clap(long, short = 't', value_name = "TEMPLATE")]
+        /// Game template to scaffold from
+        #[clap(long, short = 't', value_name = "TEMPLATE", value_parser = game_templates())]
         template: String,
     },
     /// New package (library) that other games or packages can depend on
     Package {
         /// Package name in `namespace:name` form (e.g. `acme:physics`)
         #[clap(long, short = 'n', value_name = "NAME")]
         name: String,
-        /// One of: lib-rust
-        #[clap(long, short = 't', value_name = "TEMPLATE")]
+        /// Package template to scaffold from
+        #[clap(long, short = 't', value_name = "TEMPLATE", value_parser = package_templates())]
         template: String,
     },
 }

src/commands.rs

@@ -10,6 +10,7 @@ pub mod new;
 pub mod publish;
 pub mod run;
 pub mod serve;
+pub mod wit;
 // Temporarily disabled commands — kept in the tree but not exposed via the CLI
 #[allow(dead_code)]
 pub mod update;

src/commands/wit.rs

@@ -0,0 +1,61 @@
+use std::env;
+use std::path::Path;
+
+use color_eyre::eyre::{Result, eyre};
+use toml_edit::{DocumentMut, Item, Table, value};
+
+use crate::pkg::manifest::Manifest;
+use crate::pkg::stage;
+
+/// `jumpjet wit` — re-sync the project's staged WIT to the runtime WIT embedded in
+/// *this* CLI build, then re-stage dependency WIT and regenerate the world.
+///
+/// The runtime WIT is only copied into a project at `jumpjet new` time, so after a
+/// `jumpjet upgrade` an existing project's staged runtime WIT
+/// (`.jumpjet/wit/deps/runtime` for games, `wit/deps/jumpjet-runtime` for libs)
+/// drifts from the host the CLI actually implements. This command refreshes it from
+/// the embedded definitions and pins `[runtime] version` to match, so guest bindgen
+/// generates against the runtime the installed CLI will run.
+pub async fn wit() -> Result<()> {
+    let dir = env::current_dir()?;
+    let manifest = Manifest::load_from(&dir)?;
+
+    // 1. Refresh the embedded runtime WIT into the consumer's deps dir. Games key it
+    //    as `runtime`, libs as `jumpjet-runtime` — matching `jumpjet new`.
+    let wit_root = stage::wit_root(&dir, &manifest);
+    let runtime_dest = if manifest.is_lib() {
+        wit_root.join("deps").join("jumpjet-runtime")
+    } else {
+        wit_root.join("deps").join("runtime")
+    };
+    crate::commands::new::package::copy_runtime_wit(&runtime_dest)?;
+
+    // 2. Re-resolve dependencies and re-stage their WIT, regenerating the game world.
+    let resolution = crate::pkg::resolve::resolve(&dir, false).await?;
+    stage::stage_wit(&dir, &manifest, &resolution)?;
+
+    // 3. Pin `[runtime] version` to this CLI, since the staged WIT now matches it.
+    let cli_version = env!("CARGO_PKG_VERSION");
+    set_runtime_version(&dir, cli_version)?;
+
+    println!("Synced WIT to runtime v{cli_version}");
+    Ok(())
+}
+
+/// Sets `[runtime] version` in `jumpjet.toml` to `version`, preserving the rest of
+/// the file's formatting and comments.
+fn set_runtime_version(dir: &Path, version: &str) -> Result<()> {
+    let toml_path = dir.join(Manifest::FILE_NAME);
+    let text = std::fs::read_to_string(&toml_path)?;
+    let mut doc: DocumentMut = text
+        .parse()
+        .map_err(|e| eyre!("parsing jumpjet.toml: {e}"))?;
+
+    if doc.get("runtime").is_none() {
+        doc["runtime"] = Item::Table(Table::new());
+    }
+    doc["runtime"]["version"] = value(version);
+
+    std::fs::write(&toml_path, doc.to_string())?;
+    Ok(())
+}