kustom-mc 0.1.7 → 0.1.8

package/dist/commands/new.js

@@ -84,11 +84,28 @@ export default defineScript({
     screen.open(player);
   }
 });
+`,
+    command: `import { defineCommand } from 'kustom-mc';
+
+export default defineCommand({
+  id: "{{name}}",
+  description: "A custom command",
+  execute(context) {
+    if (context.executor.isPlayer()) {
+      context.player.sendMessage("Hello from {{name}} command!");
+    } else {
+      context.process.getLogger().info("Command executed from console");
+    }
+  },
+  tabComplete(context) {
+    return ["option1", "option2"];
+  }
+});
 `
 };
 export const newCommand = new Command('new')
     .description('Generate a new script from template')
-    .argument('<type>', 'Type of script (script, block, item, gui)')
+    .argument('<type>', 'Type of script (script, block, item, gui, command)')
     .argument('<name>', 'Name of the script')
     .option('-f, --force', 'Overwrite existing file')
     .action(async (type, name, options) => {
@@ -104,7 +121,8 @@ export const newCommand = new Command('new')
         script: 'scripts',
         block: 'scripts',
         item: 'scripts',
-        gui: 'scripts'
+        gui: 'scripts',
+        command: 'scripts'
     };
     const dir = dirMap[type];
     const fileName = `${name}.ts`;

package/dist/compiler/postprocess.js

@@ -12,7 +12,7 @@
 export function postProcessForRhino(code) {
     let result = code;
     // Remove import statements for kustom-mc (handle all define functions)
-    result = result.replace(/import\s*{\s*(?:defineScript|defineBlock|defineItem)(?:\s*,\s*(?:defineScript|defineBlock|defineItem))*\s*}\s*from\s*['"]kustom-mc['"];?\s*/g, '');
+    result = result.replace(/import\s*{\s*(?:defineScript|defineBlock|defineItem|defineCommand)(?:\s*,\s*(?:defineScript|defineBlock|defineItem|defineCommand))*\s*}\s*from\s*['"]kustom-mc['"];?\s*/g, '');
     result = result.replace(/import\s+type\s*{[^}]*}\s*from\s*['"]kustom-mc['"];?\s*/g, '');
     // Convert export default defineScript({...}) to exports.default = { __type: "script", ...}
     result = result.replace(/export\s+default\s+defineScript\s*\(\s*({[\s\S]*})\s*\)\s*;?/, (match, content) => injectTypeProperty(content, 'script'));
@@ -20,6 +20,8 @@ export function postProcessForRhino(code) {
     result = result.replace(/export\s+default\s+defineBlock\s*\(\s*({[\s\S]*})\s*\)\s*;?/, (match, content) => injectTypeProperty(content, 'block'));
     // Convert export default defineItem({...}) to exports.default = { __type: "item", ...}
     result = result.replace(/export\s+default\s+defineItem\s*\(\s*({[\s\S]*})\s*\)\s*;?/, (match, content) => injectTypeProperty(content, 'item'));
+    // Convert export default defineCommand({...}) to exports.default = { __type: "command", ...}
+    result = result.replace(/export\s+default\s+defineCommand\s*\(\s*({[\s\S]*})\s*\)\s*;?/, (match, content) => injectTypeProperty(content, 'command'));
     // Convert any remaining export default to exports.default
     result = result.replace(/export\s+default\s+/g, 'exports.default = ');
     // Convert const/let to var for maximum Rhino compatibility

package/dist/compiler/rhino-plugin.js

@@ -42,12 +42,13 @@ export function transformForRhino(code) {
     // 3. Remove any remaining import statements (shouldn't be any, but just in case)
     result = result.replace(/^import\s+.*?from\s+['"][^'"]+['"];?\s*$/gm, '');
     result = result.replace(/^import\s+['"][^'"]+['"];?\s*$/gm, '');
-    // 4. Transform defineScript/defineBlock/defineItem calls
+    // 4. Transform defineScript/defineBlock/defineItem/defineCommand calls
     // Pattern: var xxx = defineScript({ ... });
     // Result:  var xxx = { __type: "script", ... };
     result = transformDefineCall(result, 'defineScript', 'script');
     result = transformDefineCall(result, 'defineBlock', 'block');
     result = transformDefineCall(result, 'defineItem', 'item');
+    result = transformDefineCall(result, 'defineCommand', 'command');
     // 5. Handle ESM export: export { xxx as default };
     result = result.replace(/export\s*\{\s*(\w+)\s+as\s+default\s*\}\s*;?/g, 'exports.default = $1;');
     // 6. Handle other ESM exports: export { foo, bar };

package/dist/runtime.d.ts

@@ -8,7 +8,7 @@
  * plain objects with __type property injected.
  */
 import './types/globals.js';
-import type { ScriptConfig, ScriptConfigWithMethods, ExportedScript, PropSchema, EventSchema, EmptyEventSchema, BlockConfig, BlockDefinition, ItemConfig, ItemDefinition, ScreenConstructor, ContainerConstructor, ElementFactory, ScriptableLocationFactory, PropsAPI, CellStateUtils, MethodMap } from './types/index.js';
+import type { ScriptConfig, ScriptConfigWithMethods, ExportedScript, PropSchema, EventSchema, EmptyEventSchema, BlockConfig, BlockDefinition, ItemConfig, ItemDefinition, CommandConfig, CommandDefinition, ScreenConstructor, ContainerConstructor, ElementFactory, ScriptableLocationFactory, PropsAPI, CellStateUtils, MethodMap } from './types/index.js';
 /**
  * Screen constructor - create new screens for GUIs.
  * Actual value is injected by Java at runtime.
@@ -131,4 +131,24 @@ export declare function defineBlock(config: BlockConfig): BlockDefinition;
  * });
  */
 export declare function defineItem(config: ItemConfig): ItemDefinition;
-export type { ScriptConfig, ScriptDefinition, ExportedScript, BaseScriptContext, ScriptContext, PropSchema, PropAPI, InferProps, PropsAPI, WrappedMethods, MethodMap, EventSchema, EmptyEventSchema, InferEventPayload, ScriptModule, ScriptProcess, TypedScriptProcess, InferScriptModule, McModuleAPI, TypedMcModuleAPI, ProcessExecutorAPI, CameraAPI, SessionAPI, ChatGUIAPI, CommandManager, BetterModelEntityAPI, ShaperAPI, ItemAPI, DefinitionBuilder, ScriptablePlayer, BlockConfig, BlockDefinition, BlockClickEvent, BlockBreakEvent, BlockPlaceEvent, ItemConfig, ItemDefinition, ScreenConstructor, ContainerConstructor, ElementFactory, ScriptableLocationFactory, CellStateUtils, } from './types/index.js';
+/**
+ * Define a custom command with type safety.
+ *
+ * Commands are registered with the CommandManager and can have
+ * arguments, permissions, and execution handlers.
+ *
+ * @example
+ * import { defineCommand } from 'kustom-mc';
+ *
+ * export default defineCommand({
+ *   name: "greet",
+ *   description: "Greet a player",
+ *   permission: "kustom.greet",
+ *
+ *   execute(ctx) {
+ *     ctx.sender.sendMessage("Hello!");
+ *   }
+ * });
+ */
+export declare function defineCommand(config: CommandConfig): CommandDefinition;
+export type { ScriptConfig, ScriptDefinition, ExportedScript, BaseScriptContext, ScriptContext, PropSchema, PropAPI, InferProps, PropsAPI, WrappedMethods, MethodMap, EventSchema, EmptyEventSchema, InferEventPayload, ScriptModule, ScriptProcess, TypedScriptProcess, InferScriptModule, McModuleAPI, TypedMcModuleAPI, ProcessExecutorAPI, CameraAPI, SessionAPI, ChatGUIAPI, CommandManager, BetterModelEntityAPI, ShaperAPI, ItemAPI, DefinitionBuilder, ScriptablePlayer, BlockConfig, BlockDefinition, BlockClickEvent, BlockBreakEvent, BlockPlaceEvent, ItemConfig, ItemDefinition, CommandConfig, CommandDefinition, ScreenConstructor, ContainerConstructor, ElementFactory, ScriptableLocationFactory, CellStateUtils, } from './types/index.js';

package/dist/runtime.js

@@ -69,3 +69,26 @@ export function defineItem(config) {
     // Simply return the config - the Java side will handle registration
     return config;
 }
+/**
+ * Define a custom command with type safety.
+ *
+ * Commands are registered with the CommandManager and can have
+ * arguments, permissions, and execution handlers.
+ *
+ * @example
+ * import { defineCommand } from 'kustom-mc';
+ *
+ * export default defineCommand({
+ *   name: "greet",
+ *   description: "Greet a player",
+ *   permission: "kustom.greet",
+ *
+ *   execute(ctx) {
+ *     ctx.sender.sendMessage("Hello!");
+ *   }
+ * });
+ */
+export function defineCommand(config) {
+    // Simply return the config - the Java side will handle registration
+    return config;
+}

package/dist/types/index.d.ts

@@ -316,39 +316,57 @@ export interface ItemConfig {
 export interface ItemDefinition extends ItemConfig {
     readonly __type: "item";
 }
+export interface ExecutionContext {
+    process: McModuleAPI;
+    executor: ProcessExecutorAPI;
+    player?: ScriptablePlayer;
+    camera: CameraAPI;
+    session: SessionAPI;
+    chatGUI: ChatGUIAPI;
+    command: CommandManager;
+    entity: BetterModelEntityAPI;
+    shaper: ShaperAPI;
+    items: ItemAPI;
+    definition: DefinitionBuilder;
+    storage: StorageAPI;
+}
+export interface ScriptContext<P = Record<string, unknown>, E extends EventSchema = EmptyEventSchema, Methods = Record<string, never>> extends ExecutionContext {
+    process: TypedMcModuleAPI<E>;
+    props: P;
+    methods: Methods;
+}
+export interface CommandContext extends ExecutionContext {
+    args: string[];
+}
+export interface CommandConfig {
+    /** Unique identifier for the command (e.g., "hello", "spawn") */
+    id: string;
+    /** Description shown in help text */
+    description?: string;
+    /** Bukkit permission node. If set, only players with this permission can use the command. Compatible with LuckPerms and other permission plugins. */
+    permission?: string;
+    /** Called when the command is executed. Receives a CommandContext object. */
+    execute: (context: CommandContext) => void;
+    /** Called for tab completion. Receives a CommandContext object. Return an array of suggestions. */
+    tabComplete?: (context: CommandContext) => string[];
+}
+export interface CommandDefinition extends CommandConfig {
+    readonly __type: "command";
+}
 /**
  * Base context passed to method functions.
  * Same as ScriptContext but without `methods` to avoid circular generic inference.
  * At runtime, Java actually injects the full context including methods.
+ * Extends ExecutionContext for consistency across all context types.
  *
  * @typeParam P - Inferred props type
  * @typeParam E - Event schema type
  */
-export interface BaseScriptContext<P = Record<string, unknown>, E extends EventSchema = EmptyEventSchema> {
+export interface BaseScriptContext<P = Record<string, unknown>, E extends EventSchema = EmptyEventSchema> extends ExecutionContext {
     /** Process API for script management (typed for events if declared) */
     process: TypedMcModuleAPI<E>;
     /** Validated props */
     props: P;
-    /** Who executed this script */
-    executor: ProcessExecutorAPI;
-    /** Camera system for cinematic views */
-    camera: CameraAPI;
-    /** Chat session system */
-    session: SessionAPI;
-    /** Chat GUI system */
-    chatGUI: ChatGUIAPI;
-    /** Command registration system */
-    command: CommandManager;
-    /** BetterModel entity system */
-    entity: BetterModelEntityAPI;
-    /** Shaper (custom block) system */
-    shaper: ShaperAPI;
-    /** Custom item system */
-    items: ItemAPI;
-    /** Model definition builder */
-    definition: DefinitionBuilder;
-    /** Persistent storage system */
-    storage: StorageAPI;
 }
 /**
  * Full context passed to the script `run()` function.
@@ -1397,8 +1415,12 @@ export interface ColumnConfig {
     setMargin(margin: number): ColumnConfig;
 }
 export interface CommandManager {
-    register(name: string, callback: () => unknown): number;
-    registerWithArgs(name: string, callback: (sender: string, args: string[]) => unknown): number;
+    /**
+     * Register a command. The callback receives (sender, ...args) where sender is the
+     * player name and args are the space-separated arguments from `/kustom command <name> <args>`.
+     * Returns the command ID.
+     */
+    register(name: string, callback: (sender: string, ...args: string[]) => unknown): number;
     unregister(commandId: number): void;
     givePlayer(playerName: string, commandId: number): void;
     removePlayer(playerName: string, commandId: number): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kustom-mc",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "CLI and type library for kustompack development",
   "type": "module",
   "main": "dist/runtime.js",