@rune-cli/rune 0.0.7 → 0.0.9

package/dist/cli.mjs

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
-import "./dist-FWLEc-op.mjs";
-import { n as isHelpFlag, r as isVersionFlag, t as runManifestCommand } from "./run-manifest-command-BmeVwPA5.mjs";
+import "./dist-DuisScgY.mjs";
+import { n as isHelpFlag, r as isVersionFlag, t as runManifestCommand } from "./run-manifest-command-BphalAwU.mjs";
 import { fileURLToPath } from "node:url";
 import { build } from "esbuild";
 import { cp, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import ts from "typescript";
 //#region package.json
-var version = "0.0.7";
+var version = "0.0.9";
 //#endregion
 //#region src/manifest/generate-manifest.ts
 const COMMAND_ENTRY_FILE = "index.ts";
@@ -94,7 +94,9 @@ async function walkCommandsDirectory(absoluteDirectoryPath, pathSegments, extrac
 }
 async function generateCommandManifest(options) {
 	const extractDescription = options.extractDescription ?? extractDescriptionFromSourceFile;
-	return { nodes: [...(await walkCommandsDirectory(options.commandsDirectory, [], extractDescription)).nodes].sort((left, right) => comparePathSegments(left.pathSegments, right.pathSegments)) };
+	const walkResult = await walkCommandsDirectory(options.commandsDirectory, [], extractDescription);
+	if (walkResult.nodes.length === 0) throw new Error("No commands found in src/commands/. Create a command file like src/commands/hello/index.ts");
+	return { nodes: [...walkResult.nodes].sort((left, right) => comparePathSegments(left.pathSegments, right.pathSegments)) };
 }
 function serializeCommandManifest(manifest) {
 	return JSON.stringify(manifest, null, 2);

package/dist/{dist-FWLEc-op.mjs → dist-DuisScgY.mjs}

@@ -4,6 +4,34 @@ function isSchemaField(field) {
 	return "schema" in field && field.schema !== void 0;
 }
 const DEFINED_COMMAND_BRAND = Symbol.for("@rune-cli/defined-command");
+const OPTION_NAME_RE = /^[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)*$/;
+const ALIAS_RE = /^[a-zA-Z]$/;
+function validateFieldShape(fields, kind) {
+	for (const field of fields) {
+		const raw = field;
+		if (raw.schema === void 0 && raw.type === void 0) throw new Error(`${kind === "argument" ? "Argument" : "Option"} "${raw.name}" must have either a "type" or "schema" property.`);
+	}
+}
+function validateUniqueFieldNames(fields, kind) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const field of fields) {
+		if (field.name.length === 0) throw new Error(`Invalid ${kind} name "${field.name}". Names must be non-empty.`);
+		if (seen.has(field.name)) throw new Error(`Duplicate ${kind} name "${field.name}".`);
+		seen.add(field.name);
+	}
+}
+function validateOptionNames(options) {
+	for (const field of options) if (!OPTION_NAME_RE.test(field.name)) throw new Error(`Invalid option name "${field.name}". Option names must start with a letter and contain only letters, numbers, and internal hyphens.`);
+}
+function validateOptionAliases(options) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const field of options) {
+		if (field.alias === void 0) continue;
+		if (!ALIAS_RE.test(field.alias)) throw new Error(`Invalid alias "${field.alias}" for option "${field.name}". Alias must be a single letter.`);
+		if (seen.has(field.alias)) throw new Error(`Duplicate alias "${field.alias}" for option "${field.name}".`);
+		seen.add(field.alias);
+	}
+}
 function isOptionalArg(field) {
 	if (isSchemaField(field)) return;
 	return field.required !== true || field.default !== void 0;
@@ -69,7 +97,18 @@ function validateArgOrdering(args) {
 * the ordering check is skipped for that field.
 */
 function defineCommand(input) {
-	if (input.args) validateArgOrdering(input.args);
+	if (typeof input.run !== "function") throw new Error("defineCommand() requires a \"run\" function.");
+	if (input.args) {
+		validateFieldShape(input.args, "argument");
+		validateUniqueFieldNames(input.args, "argument");
+		validateArgOrdering(input.args);
+	}
+	if (input.options) {
+		validateFieldShape(input.options, "option");
+		validateUniqueFieldNames(input.options, "option");
+		validateOptionNames(input.options);
+		validateOptionAliases(input.options);
+	}
 	const command = {
 		description: input.description,
 		args: input.args ?? [],
@@ -92,8 +131,10 @@ function formatExecutionError(error) {
 }
 async function executeCommand(command, input = {}) {
 	try {
+		const options = { ...input.options };
+		for (const field of command.options) if (options[field.name] === void 0 && !isSchemaField(field) && field.type === "boolean") options[field.name] = false;
 		await command.run({
-			options: input.options ?? {},
+			options,
 			args: input.args ?? {},
 			cwd: input.cwd ?? process.cwd(),
 			rawArgs: input.rawArgs ?? []
@@ -172,60 +213,48 @@ function formatOptionLabel(field) {
 function formatArgumentLabel(field) {
 	return field.name;
 }
-function missingRequiredOption(field) {
+function createMissingOptionError(field) {
 	return {
 		ok: false,
 		error: { message: `Missing required option:\n\n  ${formatOptionLabel(field)}` }
 	};
 }
-function missingRequiredArgument(field) {
+function createMissingArgumentError(field) {
 	return {
 		ok: false,
 		error: { message: `Missing required argument:\n\n  ${formatArgumentLabel(field)}` }
 	};
 }
-function invalidOptionValue(field, messages) {
+function createInvalidOptionError(field, messages) {
 	return {
 		ok: false,
 		error: { message: `Invalid value for option ${formatOptionLabel(field)}:\n\n  ${messages.join("\n  ")}` }
 	};
 }
-function invalidArgumentValue(field, messages) {
+function createInvalidArgumentError(field, messages) {
 	return {
 		ok: false,
 		error: { message: `Invalid value for argument ${formatArgumentLabel(field)}:\n\n  ${messages.join("\n  ")}` }
 	};
 }
-function unknownOption(token) {
+function createUnknownOptionError(token) {
 	return {
 		ok: false,
 		error: { message: `Unknown option "${token}"` }
 	};
 }
-function duplicateOption(field) {
+function createDuplicateOptionError(field) {
 	return {
 		ok: false,
 		error: { message: `Duplicate option "${formatOptionLabel(field)}" is not supported` }
 	};
 }
-function unexpectedArgument(token) {
+function createUnexpectedArgumentError(token) {
 	return {
 		ok: false,
 		error: { message: `Unexpected argument "${token}"` }
 	};
 }
-function normalizeParseArgsError(error) {
-	if (!(error instanceof Error)) return {
-		ok: false,
-		error: { message: "Argument parsing failed" }
-	};
-	const unknownMatch = error.message.match(/Unknown option '([^']+)'/);
-	if (unknownMatch) return unknownOption(unknownMatch[1]);
-	return {
-		ok: false,
-		error: { message: error.message }
-	};
-}
 function parsePrimitiveValue(field, rawValue) {
 	if (isSchemaField(field)) throw new Error("Schema fields must be handled separately");
 	switch (field.type) {
@@ -312,9 +341,9 @@ async function resolveMissingField(field, missingRequired) {
 	};
 }
 async function parseArgumentField(field, rawValue) {
-	if (rawValue === void 0) return resolveMissingField(field, () => missingRequiredArgument(field));
+	if (rawValue === void 0) return resolveMissingField(field, () => createMissingArgumentError(field));
 	const result = await parseProvidedField(field, rawValue);
-	if (!result.ok) return invalidArgumentValue(field, result.error.message.split("\n"));
+	if (!result.ok) return createInvalidArgumentError(field, result.error.message.split("\n"));
 	return {
 		ok: true,
 		present: true,
@@ -323,13 +352,25 @@ async function parseArgumentField(field, rawValue) {
 }
 async function parseOptionField(field, rawValue) {
 	const result = await parseProvidedField(field, rawValue);
-	if (!result.ok) return invalidOptionValue(field, result.error.message.split("\n"));
+	if (!result.ok) return createInvalidOptionError(field, result.error.message.split("\n"));
 	return {
 		ok: true,
 		present: true,
 		value: result.value
 	};
 }
+function normalizeParseArgsError(error) {
+	if (!(error instanceof Error)) return {
+		ok: false,
+		error: { message: "Argument parsing failed" }
+	};
+	const unknownMatch = error.message.match(/Unknown option '([^']+)'/);
+	if (unknownMatch) return createUnknownOptionError(unknownMatch[1]);
+	return {
+		ok: false,
+		error: { message: error.message }
+	};
+}
 function getOptionParseType(field) {
 	if (isSchemaField(field)) return field.flag ? "boolean" : "string";
 	return field.type === "boolean" ? "boolean" : "string";
@@ -350,7 +391,7 @@ function detectDuplicateOption(options, tokens) {
 		counts.set(token.name, nextCount);
 		if (nextCount > 1) {
 			const field = options.find((option) => option.name === token.name);
-			if (field) return duplicateOption(field);
+			if (field) return createDuplicateOptionError(field);
 		}
 	}
 }
@@ -377,7 +418,7 @@ async function parseCommand(command, rawArgs) {
 		if (!result.ok) return result;
 		if (result.present) parsedArgs[field.name] = result.value;
 	}
-	if (parsed.positionals.length > command.args.length) return unexpectedArgument(parsed.positionals[command.args.length]);
+	if (parsed.positionals.length > command.args.length) return createUnexpectedArgumentError(parsed.positionals[command.args.length]);
 	for (const field of command.options) {
 		const rawValue = parsed.values[field.name];
 		if (rawValue !== void 0) {
@@ -386,9 +427,10 @@ async function parseCommand(command, rawArgs) {
 			if (result.present) parsedOptions[field.name] = result.value;
 			continue;
 		}
-		const result = await resolveMissingField(field, () => missingRequiredOption(field));
+		const result = await resolveMissingField(field, () => createMissingOptionError(field));
 		if (!result.ok) return result;
 		if (result.present) parsedOptions[field.name] = result.value;
+		else if (!isSchemaField(field) && field.type === "boolean") parsedOptions[field.name] = false;
 	}
 	return {
 		ok: true,

package/dist/{index-B6XsJ6ON.d.mts → index-BWxfSwrT.d.mts}

@@ -81,7 +81,13 @@ declare namespace StandardSchemaV1 {
 type PrimitiveFieldType = "string" | "number" | "boolean";
 type PrimitiveFieldValue<TType extends PrimitiveFieldType> = TType extends "string" ? string : TType extends "number" ? number : boolean;
 interface NamedField<TName extends string = string> {
-  /** Identifier used as the key in `ctx.args` / `ctx.options` and as the CLI flag name for options. */
+  /**
+   * Identifier used as the key in `ctx.args` / `ctx.options`.
+   *
+   * For args, any non-empty name is allowed.
+   * For options, names must start with a letter and may contain only letters,
+   * numbers, and internal hyphens (for example: `dry-run`, `dryRun`, `v2`).
+   */
   readonly name: TName;
   /** One-line help text shown in `--help` output. */
   readonly description?: string | undefined;
@@ -91,7 +97,8 @@ interface PrimitiveFieldBase<TName extends string, TType extends PrimitiveFieldT
   readonly type: TType;
   /**
    * When `true`, the field must be provided by the user.
-   * Omitted or `false` makes the field optional (absent fields are `undefined` in `ctx`).
+   * Omitted or `false` makes the field optional. Absent fields are `undefined`
+   * in `ctx`, except primitive boolean options, which default to `false`.
    */
   readonly required?: boolean | undefined;
   /** Value used when the user does not provide this field. Makes the field always present in `ctx`. */
@@ -153,9 +160,13 @@ type FieldInputValue<TField> = TField extends {
 type HasDefaultValue<TField> = TField extends {
   readonly default: infer TDefault;
 } ? [TDefault] extends [undefined] ? false : true : false;
-type IsRequiredField<TField> = TField extends {
+type IsRequiredField<TField, TBooleanAlwaysPresent extends boolean = false> = TField extends {
   readonly schema: infer TSchema;
-} ? IsOptionalSchemaOutput<InferSchemaOutput<TSchema>> extends true ? false : true : HasDefaultValue<TField> extends true ? true : TField extends {
+} ? IsOptionalSchemaOutput<InferSchemaOutput<TSchema>> extends true ? false : true : HasDefaultValue<TField> extends true ? true : TBooleanAlwaysPresent extends true ? TField extends {
+  readonly type: "boolean";
+} ? true : TField extends {
+  readonly required: true;
+} ? true : false : TField extends {
   readonly required: true;
 } ? true : false;
 type IsArgOptional<TField> = TField extends {
@@ -170,7 +181,7 @@ type ValidateArgOrder<TArgs> = TArgs extends readonly CommandArgField[] ? IsVali
   readonly args: never;
 } : unknown : unknown;
 type Simplify<TValue> = { [TKey in keyof TValue]: TValue[TKey] };
-type InferNamedFields<TFields extends readonly NamedField[]> = Simplify<{ [TField in TFields[number] as IsRequiredField<TField> extends true ? FieldName<TField> : never]: FieldValue<TField> } & { [TField in TFields[number] as IsRequiredField<TField> extends true ? never : FieldName<TField>]?: FieldValue<TField> }>;
+type InferNamedFields<TFields extends readonly NamedField[], TBooleanAlwaysPresent extends boolean = false> = Simplify<{ [TField in TFields[number] as IsRequiredField<TField, TBooleanAlwaysPresent> extends true ? FieldName<TField> : never]: FieldValue<TField> } & { [TField in TFields[number] as IsRequiredField<TField, TBooleanAlwaysPresent> extends true ? never : FieldName<TField>]?: FieldValue<TField> }>;
 type InferExecutionFields<TFields extends readonly NamedField[]> = Simplify<{ [TField in TFields[number] as FieldName<TField>]?: FieldInputValue<TField> }>;
 /** Runtime data passed into a command's `run` function. */
 interface CommandContext<TOptions, TArgs> {
@@ -193,6 +204,7 @@ interface DefineCommandInput<TArgsFields extends readonly CommandArgField[] | un
   /**
    * Positional arguments declared in the order they appear on the command line.
    * Required arguments must come before optional ones.
+   * Argument names must be non-empty and unique within the command.
    *
    * Each entry is either a primitive field (`{ name, type }`) or a schema
    * field (`{ name, schema }`).
@@ -200,6 +212,8 @@ interface DefineCommandInput<TArgsFields extends readonly CommandArgField[] | un
   readonly args?: TArgsFields;
   /**
    * Options declared as `--name` flags, with optional single-character aliases.
+   * Option names must be unique within the command, start with a letter, and
+   * contain only letters, numbers, and internal hyphens.
    *
    * Each entry is either a primitive field (`{ name, type }`) or a schema
    * field (`{ name, schema }`).
@@ -209,13 +223,13 @@ interface DefineCommandInput<TArgsFields extends readonly CommandArgField[] | un
    * The function executed when this command is invoked.
    * Receives a {@link CommandContext} with fully parsed `args` and `options`.
    */
-  readonly run: (ctx: CommandContext<InferNamedFields<NormalizeFields<TOptionsFields, CommandOptionField>>, InferNamedFields<NormalizeFields<TArgsFields, CommandArgField>>>) => void | Promise<void>;
+  readonly run: (ctx: CommandContext<InferNamedFields<NormalizeFields<TOptionsFields, CommandOptionField>, true>, InferNamedFields<NormalizeFields<TArgsFields, CommandArgField>>>) => void | Promise<void>;
 }
 interface DefinedCommand<TArgsFields extends readonly CommandArgField[] = readonly [], TOptionsFields extends readonly CommandOptionField[] = readonly []> {
   readonly description?: string | undefined;
   readonly args: TArgsFields;
   readonly options: TOptionsFields;
-  readonly run: (ctx: CommandContext<InferNamedFields<TOptionsFields>, InferNamedFields<TArgsFields>>) => void | Promise<void>;
+  readonly run: (ctx: CommandContext<InferNamedFields<TOptionsFields, true>, InferNamedFields<TArgsFields>>) => void | Promise<void>;
 } //#endregion
 //#region src/define-command.d.ts
 /**

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { a as ExecuteCommandInput, c as PrimitiveFieldType, d as SchemaOptionField, f as defineCommand, i as DefinedCommand, l as PrimitiveOptionField, n as CommandContext, o as InferExecutionFields, r as CommandOptionField, s as PrimitiveArgField, t as CommandArgField, u as SchemaArgField } from "./index-B6XsJ6ON.mjs";
+import { a as ExecuteCommandInput, c as PrimitiveFieldType, d as SchemaOptionField, f as defineCommand, i as DefinedCommand, l as PrimitiveOptionField, n as CommandContext, o as InferExecutionFields, r as CommandOptionField, s as PrimitiveArgField, t as CommandArgField, u as SchemaArgField } from "./index-BWxfSwrT.mjs";
 export { type CommandArgField, type CommandContext, type CommandOptionField, type DefinedCommand, type ExecuteCommandInput, type InferExecutionFields, type PrimitiveArgField, type PrimitiveFieldType, type PrimitiveOptionField, type SchemaArgField, type SchemaOptionField, defineCommand };

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { n as defineCommand } from "./dist-FWLEc-op.mjs";
+import { n as defineCommand } from "./dist-DuisScgY.mjs";
 export { defineCommand };

package/dist/{run-manifest-command-BmeVwPA5.mjs → run-manifest-command-BphalAwU.mjs}

@@ -1,4 +1,4 @@
-import { a as isSchemaField, i as isDefinedCommand, o as parseCommand, r as executeCommand } from "./dist-FWLEc-op.mjs";
+import { a as isSchemaField, i as isDefinedCommand, o as parseCommand, r as executeCommand } from "./dist-DuisScgY.mjs";
 import { pathToFileURL } from "node:url";
 //#region src/cli/flags.ts
 function isHelpFlag(token) {

package/dist/runtime.d.mts

@@ -1,4 +1,4 @@
-import { i as DefinedCommand, r as CommandOptionField, t as CommandArgField } from "./index-B6XsJ6ON.mjs";
+import { i as DefinedCommand, r as CommandOptionField, t as CommandArgField } from "./index-BWxfSwrT.mjs";
 
 //#region src/manifest/manifest-types.d.ts
 type CommandManifestPath = readonly string[];

package/dist/runtime.mjs

@@ -1,3 +1,3 @@
-import "./dist-FWLEc-op.mjs";
-import { t as runManifestCommand } from "./run-manifest-command-BmeVwPA5.mjs";
+import "./dist-DuisScgY.mjs";
+import { t as runManifestCommand } from "./run-manifest-command-BphalAwU.mjs";
 export { runManifestCommand };

package/dist/test.d.mts

@@ -1,4 +1,4 @@
-import { a as ExecuteCommandInput, i as DefinedCommand, o as InferExecutionFields, r as CommandOptionField, t as CommandArgField } from "./index-B6XsJ6ON.mjs";
+import { a as ExecuteCommandInput, i as DefinedCommand, o as InferExecutionFields, r as CommandOptionField, t as CommandArgField } from "./index-BWxfSwrT.mjs";
 
 //#region src/test.d.ts
 type RunCommandOptions<TOptions, TArgs> = ExecuteCommandInput<TOptions, TArgs>;

package/dist/test.mjs

@@ -1,4 +1,4 @@
-import { r as executeCommand, t as captureProcessOutput } from "./dist-FWLEc-op.mjs";
+import { r as executeCommand, t as captureProcessOutput } from "./dist-DuisScgY.mjs";
 //#region src/test.ts
 /**
 * Runs a command definition directly in-process for testing.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rune-cli/rune",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Rune is a CLI framework built around the concept of file-based command routing.",
   "homepage": "https://github.com/morinokami/rune#readme",
   "bugs": {