kraftlin-command-core/io.github.kraftlin.command

Package-level declarations

Core DSL primitives and node builders used to construct command trees.

This package contains:

Entry points like io.github.kraftlin.command.brigadierCommand for creating command trees.
Node builders like io.github.kraftlin.command.literal and io.github.kraftlin.command.argument.
io.github.kraftlin.command.KContext for idiomatic argument retrieval.
Execution builders like io.github.kraftlin.command.executes and io.github.kraftlin.command.executesResult.
Requirement builders like io.github.kraftlin.command.requires.

All functionality here is platform-agnostic and does not depend on Paper or Minecraft classes.

Types

ArgumentNode

class ArgumentNode<S, T> : LiteralNode<S>

Scope for building a required argument node. Extends LiteralNode with suggests.

CommandDsl

@DslMarker

annotation class CommandDsl

Marks Kraftlin command DSL scopes to prevent accidental nesting.

ExecuteScope

class ExecuteScope<S>

Receiver for command execution blocks. Prevents nesting DSL scopes inside executes.

KContext

class KContext<S>(val rawContext: CommandContext<S>)

Typed accessor for retrieving parsed argument values from a Brigadier CommandContext.

LiteralNode

open class LiteralNode<S>

Scope for building a command tree node. Provides literal, argument, executes, and requires.

PlatformAdapter

interface PlatformAdapter<S, Sender>

Abstraction over platform-specific command source handling.

Functions

argument

fun <S, T> LiteralNode<S>.argument(name: String, type: ArgumentType<T>, block: ArgumentNode<S, T>.() -> Unit)

Adds a required argument of the given Brigadier type. Prefer the typed helpers (e.g. string, integer).

boolean

fun <S> LiteralNode<S>.boolean(name: String, block: ArgumentNode<S, Boolean>.() -> Unit)

Adds a boolean argument.

brigadierCommand

fun <S> brigadierCommand(name: String, block: LiteralNode<S>.() -> Unit): LiteralCommandNode<S>

Builds a Brigadier command tree rooted at a literal node named name.

double

fun <S> LiteralNode<S>.double(name: String, block: ArgumentNode<S, Double>.() -> Unit)

Adds a double argument.

fun <S> LiteralNode<S>.double(name: String, min: Double, block: ArgumentNode<S, Double>.() -> Unit)

Adds a double argument with minimum min.

fun <S> LiteralNode<S>.double(name: String, min: Double, max: Double, block: ArgumentNode<S, Double>.() -> Unit)

Adds a double argument bounded to min..max.

executes

fun <S> LiteralNode<S>.executes(block: ExecuteScope<S>.(KContext<S>) -> Unit)

Registers the execution handler for this node. Returns Command.SINGLE_SUCCESS automatically.

fun <S, Sender> LiteralNode<S>.executes(platform: PlatformAdapter<S, Sender>, block: ExecuteScope<S>.(Sender, KContext<S>) -> Unit)

Execution handler that extracts the platform Sender before invoking block.

executesResult

fun <S> LiteralNode<S>.executesResult(block: ExecuteScope<S>.(KContext<S>) -> Int)

Registers an execution handler that returns a custom Brigadier result code.

fun <S, Sender> LiteralNode<S>.executesResult(platform: PlatformAdapter<S, Sender>, block: ExecuteScope<S>.(Sender, KContext<S>) -> Int)

Execution handler with custom result code that extracts the platform Sender before invoking block.

float

fun <S> LiteralNode<S>.float(name: String, block: ArgumentNode<S, Float>.() -> Unit)

Adds a float argument.

fun <S> LiteralNode<S>.float(name: String, min: Float, block: ArgumentNode<S, Float>.() -> Unit)

Adds a float argument with minimum min.

fun <S> LiteralNode<S>.float(name: String, min: Float, max: Float, block: ArgumentNode<S, Float>.() -> Unit)

Adds a float argument bounded to min..max.

greedyString

fun <S> KContext<S>.greedyString(name: String): String

Returns the string value. Alias for string. @see LiteralNode.greedyString

fun <S> LiteralNode<S>.greedyString(name: String, block: ArgumentNode<S, String>.() -> Unit)

Adds a greedy string argument that consumes all remaining input. @see KContext.greedyString

integer

fun <S> LiteralNode<S>.integer(name: String, block: ArgumentNode<S, Int>.() -> Unit)

Adds an integer argument.

fun <S> LiteralNode<S>.integer(name: String, min: Int, block: ArgumentNode<S, Int>.() -> Unit)

Adds an integer argument with minimum min.

fun <S> LiteralNode<S>.integer(name: String, min: Int, max: Int, block: ArgumentNode<S, Int>.() -> Unit)

Adds an integer argument bounded to min..max.

literal

fun <S> LiteralNode<S>.literal(name: String, vararg aliases: String, block: LiteralNode<S>.() -> Unit)

Adds a literal sub-command named name with optional aliases that redirect to it.

long

fun <S> LiteralNode<S>.long(name: String, block: ArgumentNode<S, Long>.() -> Unit)

Adds a long argument.

fun <S> LiteralNode<S>.long(name: String, min: Long, block: ArgumentNode<S, Long>.() -> Unit)

Adds a long argument with minimum min.

fun <S> LiteralNode<S>.long(name: String, min: Long, max: Long, block: ArgumentNode<S, Long>.() -> Unit)

Adds a long argument bounded to min..max.

requires

fun <S> LiteralNode<S>.requires(predicate: (S) -> Boolean)

Adds a requirement that must be true for this node to be visible and executable. Stacks with previous requirements.

requiresPermission

fun <S, Sender> LiteralNode<S>.requiresPermission(platform: PlatformAdapter<S, Sender>, permission: String)

Requires the source to have the given permission, checked via platform.

requiresSender

fun <S, Sender> LiteralNode<S>.requiresSender(platform: PlatformAdapter<S, Sender>, predicate: (Sender) -> Boolean)

Requires the platform sender to match a predicate (e.g. to check sender type).

string

fun <S> LiteralNode<S>.string(name: String, block: ArgumentNode<S, String>.() -> Unit)

Adds a quoted or single-word string argument.

suggests

fun <S, T> ArgumentNode<S, T>.suggests(provider: (KContext<S>, SuggestionsBuilder) -> CompletableFuture<Suggestions>)

Registers a dynamic suggestion provider for this argument.

suggestsStatic

fun <S, T> ArgumentNode<S, T>.suggestsStatic(vararg values: String)

fun <S, T> ArgumentNode<S, T>.suggestsStatic(values: Iterable<String>)

Registers a fixed set of suggestion values for this argument.

word

fun <S> KContext<S>.word(name: String): String

Returns the string value. Alias for string. @see LiteralNode.word

fun <S> LiteralNode<S>.word(name: String, block: ArgumentNode<S, String>.() -> Unit)

Adds a single-word string argument. @see KContext.word