Vanilla-ish commands

Cargo.toml

@@ -26,7 +26,7 @@ members = [
     "src/blocks/crates/build",
     "src/blocks/crates/data",
     "src/bin",
-    "src/commands",
+    "src/command-infra",
     "src/components",
     "src/core",
     "src/dashboard",
@@ -129,14 +129,14 @@ temper-block-data = { path = "src/blocks/crates/data" }
 temper-config = { path = "src/config" }
 temper-core = { path = "src/core" }
 temper-default-commands = { path = "src/default_commands" }
-temper-commands = { path = "src/commands" }
 temper-general-purpose = { path = "src/base/general_purpose" }
 temper-logging = { path = "src/base/logging" }
 temper-macros = { path = "src/base/macros" }
 temper-nbt = { path = "src/adapters/nbt" }
 temper-net-runtime = { path = "src/net/runtime" }
 temper-performance = { path = "src/performance" }
 temper-codec = { path = "src/net/codec" }
+temper-command-infra = { path = "src/command-infra" }
 temper-protocol = { path = "src/net/protocol" }
 temper-encryption = { path = "src/net/encryption" }
 temper-profiling = { path = "src/base/profiling" }
@@ -180,7 +180,7 @@ tracing = "0.1.44"
 tracing-subscriber = { version = "0.3.23", features = ["env-filter"] }
 tracing-appender = "0.2.5"
 tracing-tracy = { version = "0.11.4", features = ["timer-fallback", "ondemand", "fibers", "context-switch-tracing", "delayed-init"] }
-log = "0.4.32"
+log = "0.4.33"
 tracy-client = "0.18.4"
 
 # Concurrency/Parallelism
@@ -195,7 +195,7 @@ reqwest = { version = "0.13.4", features = ["json", "native-tls", "blocking", "h
 
 # Error handling
 thiserror = "2.0.18"
-anyhow = "1.0.102"
+anyhow = "1.0.103"
 
 # Cryptography
 rand = "0.10.1"
@@ -228,16 +228,16 @@ byteorder = "1.5.0"
 
 # Data types
 dashmap = { version = "7.0.0-rc2", features = ["serde"] }
-uuid = { version = "1.23.3", features = ["v4", "v3", "serde"] }
+uuid = { version = "1.23.4", features = ["v4", "v3", "serde"] }
 indexmap = { version = "2.14.0", features = ["serde"] }
 bimap = "0.6.3"
-arrayvec = "0.7.6"
+arrayvec = "0.7.7"
 fastcache = "0.1.7"
 
 # Macros
 lazy_static = "1.5.0"
-quote = "1.0.45"
-syn = { version = "2.0.117", features = ["extra-traits"] }
+quote = "1.0.46"
+syn = { version = "2.0.118", features = ["extra-traits", "full"] }
 proc-macro2 = "1.0.106"
 paste = "1.0.15"
 maplit = "1.0.2"
@@ -260,7 +260,7 @@ heed = "0.22.1"
 # Misc
 deepsize = "0.2.0"
 page_size = "0.6.0"
-enum-ordinalize = "4.3.2"
+enum-ordinalize = "4.4.1"
 regex = "1.12.4"
 noise = "0.9.0"
 ctrlc = "3.5.2"
@@ -274,9 +274,9 @@ mime_guess = "2.0.5"
 
 ## TUI/CLI
 crossterm = "0.29.0"
-ratatui-core = "0.1.1"
+ratatui-core = "0.1.2"
 tui-input = "0.15.3"
-ratatui = "0.30.1"
+ratatui = "0.30.2"
 tui-logger = { version = "0.18.2", features = ["tracing-support", "crossterm"] }
 clap = { version = "4.6.1", features = ["derive", "env"] }
 indicatif = "0.18.4"
@@ -285,22 +285,22 @@ unicode-width = "0.2.2"
 heck = "0.5.0"
 
 # I/O
-memmap2 = "0.9.10"
+memmap2 = "0.9.11"
 tempfile = "3.27.0"
 walkdir = "2.5.0"
 include_dir = "0.7.4"
 
 # Benchmarking
 criterion = { version = "0.8.2", features = ["html_reports"] }
 
-phf = { version = "0.13.1", features = ["macros"] }
-phf_codegen = { version = "0.13.1" }
+phf = { version = "0.14.0", features = ["macros"] }
+phf_codegen = { version = "0.14.0" }
 
 # Web server
 axum = { version = "0.8.9", features = ["tokio", "ws"] }
 
 # Stats
-sysinfo = { version = "0.39.3", default-features = false, features = ["system"] }
+sysinfo = { version = "0.39.5", default-features = false, features = ["system"] }
 dir-size = "0.1.1"
 
 # Compression is a real bottleneck that we can do little about, so compiling it with optimizations is needed in dev mode.

src/base/macros/src/command_derive/attrs.rs

@@ -0,0 +1,201 @@
+use syn::parse::{Parse, ParseStream};
+use syn::{
+    Attribute, Expr, ExprArray, ExprLit, Ident, Lit, LitStr, Path, Result as SynResult, Token,
+};
+
+pub enum CommandKind {
+    Root(CommandAttrs),
+    Subcommand(SubcommandAttrs),
+}
+
+pub struct CommandAttrs {
+    pub name: LitStr,
+    pub aliases: Vec<LitStr>,
+    pub permission: Option<Path>,
+}
+
+pub struct SubcommandAttrs {
+    pub permission: Option<Path>,
+}
+
+pub enum VariantPrefix {
+    Literal(PrefixAttrs),
+    Subcommand(PrefixAttrs),
+}
+
+pub struct PrefixAttrs {
+    pub name: LitStr,
+    pub aliases: Vec<LitStr>,
+}
+
+pub struct VariantAttrs {
+    pub prefix: Option<VariantPrefix>,
+    pub permission: Option<Path>,
+}
+
+pub fn command_kind(attrs: &[Attribute]) -> SynResult<CommandKind> {
+    for attr in attrs {
+        if !attr.path().is_ident("command") {
+            continue;
+        }
+
+        if let Ok(name) = attr.parse_args::<LitStr>() {
+            return Ok(CommandKind::Root(CommandAttrs {
+                name,
+                aliases: Vec::new(),
+                permission: None,
+            }));
+        }
+
+        let mut name = None;
+        let mut aliases = Vec::new();
+        let mut permission = None;
+        let mut subcommand = false;
+
+        attr.parse_nested_meta(|meta| {
+            if meta.path.is_ident("name") {
+                name = Some(meta.value()?.parse::<LitStr>()?);
+                Ok(())
+            } else if meta.path.is_ident("aliases") {
+                aliases = parse_aliases(meta.value()?.parse::<ExprArray>()?)?;
+                Ok(())
+            } else if meta.path.is_ident("permission") {
+                permission = Some(meta.value()?.parse::<Path>()?);
+                Ok(())
+            } else if meta.path.is_ident("subcommand") {
+                subcommand = true;
+                Ok(())
+            } else {
+                Err(meta.error("unsupported command option"))
+            }
+        })?;
+
+        return match (name, subcommand) {
+            (Some(name), false) => Ok(CommandKind::Root(CommandAttrs {
+                name,
+                aliases,
+                permission,
+            })),
+            (None, true) => Ok(CommandKind::Subcommand(SubcommandAttrs { permission })),
+            (Some(_), true) => Err(syn::Error::new_spanned(
+                attr,
+                "command cannot be both named and a subcommand",
+            )),
+            (None, false) => Err(syn::Error::new_spanned(
+                attr,
+                "expected #[command(\"name\")], #[command(name = \"name\")], or #[command(subcommand)]",
+            )),
+        };
+    }
+
+    Err(syn::Error::new(
+        proc_macro2::Span::call_site(),
+        "missing #[command(...)] attribute",
+    ))
+}
+
+pub fn variant_attrs(attrs: &[Attribute]) -> SynResult<VariantAttrs> {
+    let mut prefix = None;
+    let mut permission = None;
+
+    for attr in attrs {
+        let next = if attr.path().is_ident("literal") {
+            Some(VariantPrefix::Literal(attr.parse_args::<PrefixAttrs>()?))
+        } else if attr.path().is_ident("subcommand") {
+            Some(VariantPrefix::Subcommand(attr.parse_args::<PrefixAttrs>()?))
+        } else {
+            None
+        };
+
+        if let Some(next) = next {
+            if prefix.is_some() {
+                return Err(syn::Error::new_spanned(
+                    attr,
+                    "command variants can only have one #[literal(...)] or #[subcommand(...)] attribute",
+                ));
+            }
+
+            prefix = Some(next);
+            continue;
+        }
+
+        if attr.path().is_ident("permission") {
+            if permission.is_some() {
+                return Err(syn::Error::new_spanned(
+                    attr,
+                    "command variants can only have one #[permission(...)] attribute",
+                ));
+            }
+
+            permission = Some(attr.parse_args::<Path>()?);
+        }
+    }
+
+    Ok(VariantAttrs { prefix, permission })
+}
+
+pub fn permission_attr(attrs: &[Attribute]) -> SynResult<Option<Path>> {
+    let mut permission = None;
+
+    for attr in attrs {
+        if !attr.path().is_ident("permission") {
+            continue;
+        }
+
+        if permission.is_some() {
+            return Err(syn::Error::new_spanned(
+                attr,
+                "fields can only have one #[permission(...)] attribute",
+            ));
+        }
+
+        permission = Some(attr.parse_args::<Path>()?);
+    }
+
+    Ok(permission)
+}
+
+fn parse_aliases(aliases: ExprArray) -> SynResult<Vec<LitStr>> {
+    aliases
+        .elems
+        .into_iter()
+        .map(|expr| match expr {
+            Expr::Lit(ExprLit {
+                lit: Lit::Str(alias),
+                ..
+            }) => Ok(alias),
+            _ => Err(syn::Error::new_spanned(
+                expr,
+                "aliases must be string literals",
+            )),
+        })
+        .collect()
+}
+
+impl Parse for PrefixAttrs {
+    fn parse(input: ParseStream<'_>) -> SynResult<Self> {
+        let name = input.parse::<LitStr>()?;
+        let mut aliases = Vec::new();
+
+        while input.peek(Token![,]) {
+            input.parse::<Token![,]>()?;
+
+            if input.is_empty() {
+                break;
+            }
+
+            let option = input.parse::<Ident>()?;
+            if option != "aliases" {
+                return Err(syn::Error::new_spanned(
+                    option,
+                    "unsupported literal/subcommand option",
+                ));
+            }
+
+            input.parse::<Token![=]>()?;
+            aliases = parse_aliases(input.parse::<ExprArray>()?)?;
+        }
+
+        Ok(Self { name, aliases })
+    }
+}