@rune-cli/rune 0.0.1 → 0.0.3

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { i as successResult, n as runManifestCommand, r as failureResult, t as writeCommandExecutionResult } from "./write-result-C0wgFsjj.mjs";
+import { i as successResult, n as runManifestCommand, r as failureResult, t as writeCommandExecutionResult } from "./write-result-qylmqXvG.mjs";
 import { fileURLToPath } from "node:url";
 import { build } from "esbuild";
 import { cp, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
@@ -313,6 +313,21 @@ async function writeBuiltRuntimeFiles(distDirectory, manifest) {
 	await mkdir(distDirectory, { recursive: true });
 	await writeFile(path.join(distDirectory, BUILD_MANIFEST_FILENAME), serializeCommandManifest(manifest));
 }
+function renderRuneBuildHelp() {
+	return `\
+Build a Rune project into a distributable CLI.
+
+Usage: rune build [options]
+
+Options:
+  --project <path>  Path to the Rune project root (default: current directory)
+  -h, --help        Show this help message
+
+Examples:
+  rune build
+  rune build --project ./my-app
+`;
+}
 async function runBuildCommand(options) {
 	let projectRoot = "";
 	try {
@@ -340,14 +355,6 @@ async function runBuildCommand(options) {
 		return failureResult(error instanceof Error ? error.message : "Failed to run rune build");
 	}
 }
-function renderRuneBuildHelp() {
-	return [
-		"Usage: rune build [--project <path>]",
-		"",
-		"Build a Rune project into a distributable CLI.",
-		""
-	].join("\n");
-}
 //#endregion
 //#region src/cli/dev-command.ts
 const DEV_MANIFEST_DIRECTORY_PATH = ".rune";
@@ -358,6 +365,21 @@ async function writeDevManifest(projectRoot, manifestContents) {
 	await mkdir(manifestDirectory, { recursive: true });
 	await writeFile(manifestPath, manifestContents);
 }
+function renderRuneDevHelp() {
+	return `\
+Run a Rune project in development mode.
+
+Usage: rune dev [options] [command...]
+
+Options:
+  --project <path>  Path to the Rune project root (default: current directory)
+  -h, --help        Show this help message
+
+Examples:
+  rune dev hello
+  rune dev --project ./my-app hello
+`;
+}
 async function runDevCommand(options) {
 	try {
 		const projectRoot = resolveProjectPath(options);
@@ -375,24 +397,6 @@ async function runDevCommand(options) {
 		return failureResult(error instanceof Error ? error.message : "Failed to run rune dev");
 	}
 }
-function renderRuneDevHelp() {
-	return [
-		"Usage: rune dev [--project <path>] [--] [command...]",
-		"",
-		"Run a Rune project in development mode.",
-		""
-	].join("\n");
-}
-function renderRuneCliHelp() {
-	return [
-		"Usage: rune <command>",
-		"",
-		"Commands:",
-		"  build  Build a Rune project into a distributable CLI",
-		"  dev  Run a Rune project in development mode",
-		""
-	].join("\n");
-}
 //#endregion
 //#region src/cli/rune-cli.ts
 function tryParseProjectOption(argv, index) {
@@ -460,6 +464,18 @@ function parseBuildArgs(argv) {
 	}
 	return { projectPath };
 }
+function renderRuneCliHelp() {
+	return `\
+Usage: rune <command>
+
+Commands:
+  build  Build a Rune project into a distributable CLI
+  dev    Run a Rune project in development mode
+
+Options:
+  -h, --help  Show this help message
+`;
+}
 async function runRuneCli(options) {
 	const [subcommand, ...restArgs] = options.argv;
 	if (!subcommand || isHelpFlag(subcommand)) return successResult(renderRuneCliHelp());

package/dist/dist-Bcn0FpHi.mjs

@@ -0,0 +1,400 @@
+import { format, parseArgs } from "node:util";
+//#region ../core/dist/index.mjs
+function isSchemaField(field) {
+	return "schema" in field && field.schema !== void 0;
+}
+const EMPTY_FIELDS = [];
+function isOptionalArg(field) {
+	if (isSchemaField(field)) return;
+	return field.required !== true || field.default !== void 0;
+}
+function validateArgOrdering(args) {
+	let firstOptionalName;
+	for (const field of args) {
+		const optional = isOptionalArg(field);
+		if (optional === void 0) continue;
+		if (optional) firstOptionalName ??= field.name;
+		else if (firstOptionalName !== void 0) throw new Error(`Required argument "${field.name}" cannot follow optional argument "${firstOptionalName}"`);
+	}
+}
+/**
+* Defines a CLI command with a description, positional arguments, options,
+* and a function to execute when the command is invoked.
+*
+* The command module's default export should be the return value of this function.
+*
+* @example
+* ```ts
+* export default defineCommand({
+*   description: "Greet someone",
+*   args: [
+*     { name: "name", type: "string", required: true },
+*   ],
+*   options: [
+*     { name: "loud", type: "boolean", alias: "l" },
+*   ],
+*   run(ctx) {
+*     const greeting = `Hello, ${ctx.args.name}!`;
+*     console.log(ctx.options.loud ? greeting.toUpperCase() : greeting);
+*   },
+* });
+* ```
+*
+* Required positional arguments must precede optional ones. This ordering is
+* enforced at the type level for concrete schema types and at runtime for
+* primitive fields:
+*
+* ```ts
+* // Type error — required arg after optional arg
+* defineCommand({
+*   args: [
+*     { name: "source", type: "string" },
+*     { name: "target", type: "string", required: true },
+*   ],
+*   run() {},
+* });
+*
+* // Type error — required primitive arg after optional schema arg
+* defineCommand({
+*   args: [
+*     { name: "mode", schema: z.string().optional() },
+*     { name: "target", type: "string", required: true },
+*   ],
+*   run() {},
+* });
+* ```
+*
+* When a schema type is widened to plain `StandardSchemaV1` (e.g. stored in
+* a variable without a concrete type), optionality information is lost and
+* the ordering check is skipped for that field.
+*/
+function defineCommand(input) {
+	if (input.args) validateArgOrdering(input.args);
+	return {
+		description: input.description,
+		args: input.args ?? EMPTY_FIELDS,
+		options: input.options ?? EMPTY_FIELDS,
+		run: input.run
+	};
+}
+function formatExecutionError(error) {
+	if (error instanceof Error) return error.message === "" ? "" : error.message || error.name || "Unknown error";
+	if (typeof error === "string") return error;
+	return "Unknown error";
+}
+async function captureProcessOutput(action) {
+	const stdoutChunks = [];
+	const stderrChunks = [];
+	const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+	const originalStderrWrite = process.stderr.write.bind(process.stderr);
+	const originalConsoleMethods = {
+		log: console.log,
+		info: console.info,
+		debug: console.debug,
+		warn: console.warn,
+		error: console.error
+	};
+	const captureChunk = (chunks, chunk, encoding) => {
+		if (typeof chunk === "string") {
+			chunks.push(chunk);
+			return;
+		}
+		chunks.push(Buffer.from(chunk).toString(encoding));
+	};
+	const captureConsole = (chunks, args) => {
+		chunks.push(`${format(...args)}\n`);
+	};
+	const createWriteCapture = (chunks) => ((chunk, encoding, cb) => {
+		captureChunk(chunks, chunk, typeof encoding === "string" ? encoding : void 0);
+		if (typeof encoding === "function") encoding(null);
+		else cb?.(null);
+		return true;
+	});
+	process.stdout.write = createWriteCapture(stdoutChunks);
+	process.stderr.write = createWriteCapture(stderrChunks);
+	for (const method of [
+		"log",
+		"info",
+		"debug"
+	]) console[method] = (...args) => captureConsole(stdoutChunks, args);
+	for (const method of ["warn", "error"]) console[method] = (...args) => captureConsole(stderrChunks, args);
+	try {
+		const value = await action();
+		return {
+			stdout: stdoutChunks.join(""),
+			stderr: stderrChunks.join(""),
+			value
+		};
+	} catch (error) {
+		return {
+			stdout: stdoutChunks.join(""),
+			stderr: stderrChunks.join(""),
+			error
+		};
+	} finally {
+		process.stdout.write = originalStdoutWrite;
+		process.stderr.write = originalStderrWrite;
+		Object.assign(console, originalConsoleMethods);
+	}
+}
+const EMPTY_ARGS = [];
+async function executeCommand(command, input = {}) {
+	const result = await captureProcessOutput(async () => {
+		await command.run({
+			options: input.options ?? {},
+			args: input.args ?? {},
+			cwd: input.cwd ?? process.cwd(),
+			rawArgs: input.rawArgs ?? EMPTY_ARGS
+		});
+	});
+	if (result.error === void 0) return {
+		exitCode: 0,
+		stdout: result.stdout,
+		stderr: result.stderr
+	};
+	const message = formatExecutionError(result.error);
+	return {
+		exitCode: 1,
+		stdout: result.stdout,
+		stderr: `${result.stderr}${message ? `${message}\n` : ""}`
+	};
+}
+function formatFieldTypeHint(field) {
+	if (isSchemaField(field)) return "";
+	return ` <${field.type}>`;
+}
+function formatOptionLabel(field) {
+	return `--${field.name}${formatFieldTypeHint(field)}`;
+}
+function formatArgumentLabel(field) {
+	return field.name;
+}
+function missingRequiredOption(field) {
+	return {
+		ok: false,
+		error: { message: `Missing required option:\n\n  ${formatOptionLabel(field)}` }
+	};
+}
+function missingRequiredArgument(field) {
+	return {
+		ok: false,
+		error: { message: `Missing required argument:\n\n  ${formatArgumentLabel(field)}` }
+	};
+}
+function invalidOptionValue(field, messages) {
+	return {
+		ok: false,
+		error: { message: `Invalid value for option ${formatOptionLabel(field)}:\n\n  ${messages.join("\n  ")}` }
+	};
+}
+function invalidArgumentValue(field, messages) {
+	return {
+		ok: false,
+		error: { message: `Invalid value for argument ${formatArgumentLabel(field)}:\n\n  ${messages.join("\n  ")}` }
+	};
+}
+function unknownOption(token) {
+	return {
+		ok: false,
+		error: { message: `Unknown option "${token}"` }
+	};
+}
+function duplicateOption(field) {
+	return {
+		ok: false,
+		error: { message: `Duplicate option "${formatOptionLabel(field)}" is not supported` }
+	};
+}
+function unexpectedArgument(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) {
+		case "string": return {
+			ok: true,
+			value: String(rawValue)
+		};
+		case "number": {
+			if (typeof rawValue !== "string") return {
+				ok: false,
+				error: { message: `Expected number, received ${JSON.stringify(rawValue)}` }
+			};
+			const value = Number(rawValue);
+			if (!Number.isFinite(value)) return {
+				ok: false,
+				error: { message: `Expected number, received ${JSON.stringify(rawValue)}` }
+			};
+			return {
+				ok: true,
+				value
+			};
+		}
+		case "boolean":
+			if (typeof rawValue === "boolean") return {
+				ok: true,
+				value: rawValue
+			};
+			if (rawValue === "true") return {
+				ok: true,
+				value: true
+			};
+			if (rawValue === "false") return {
+				ok: true,
+				value: false
+			};
+			return {
+				ok: false,
+				error: { message: `Expected boolean, received ${JSON.stringify(rawValue)}` }
+			};
+	}
+}
+async function validateSchemaValue(schema, rawValue) {
+	const result = await schema["~standard"].validate(rawValue);
+	if ("value" in result) return {
+		ok: true,
+		value: result.value
+	};
+	if (result.issues?.length) return {
+		ok: false,
+		error: { message: result.issues.map((issue) => issue.message).join("\n") }
+	};
+	return {
+		ok: false,
+		error: { message: "Schema validation failed" }
+	};
+}
+async function parseProvidedField(field, rawValue) {
+	if (isSchemaField(field)) return validateSchemaValue(field.schema, rawValue);
+	return parsePrimitiveValue(field, rawValue);
+}
+async function resolveMissingField(field, missingRequired) {
+	if (!isSchemaField(field)) {
+		if (field.default !== void 0) return {
+			ok: true,
+			present: true,
+			value: field.default
+		};
+		if (field.required) return missingRequired();
+		return {
+			ok: true,
+			present: false
+		};
+	}
+	const omittedResult = await validateSchemaValue(field.schema, void 0);
+	if (!omittedResult.ok) return missingRequired();
+	if (omittedResult.value === void 0) return {
+		ok: true,
+		present: false
+	};
+	return {
+		ok: true,
+		present: true,
+		value: omittedResult.value
+	};
+}
+async function parseArgumentField(field, rawValue) {
+	if (rawValue === void 0) return resolveMissingField(field, () => missingRequiredArgument(field));
+	const result = await parseProvidedField(field, rawValue);
+	if (!result.ok) return invalidArgumentValue(field, result.error.message.split("\n"));
+	return {
+		ok: true,
+		present: true,
+		value: result.value
+	};
+}
+async function parseOptionField(field, rawValue) {
+	const result = await parseProvidedField(field, rawValue);
+	if (!result.ok) return invalidOptionValue(field, result.error.message.split("\n"));
+	return {
+		ok: true,
+		present: true,
+		value: result.value
+	};
+}
+function getOptionParseType(field) {
+	if (isSchemaField(field)) return field.flag ? "boolean" : "string";
+	return field.type === "boolean" ? "boolean" : "string";
+}
+function buildParseArgsOptions(options) {
+	const config = {};
+	for (const field of options) config[field.name] = field.alias ? {
+		type: getOptionParseType(field),
+		short: field.alias
+	} : { type: getOptionParseType(field) };
+	return config;
+}
+function detectDuplicateOption(options, tokens) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const token of tokens) {
+		if (token.kind !== "option" || !token.name) continue;
+		const nextCount = (counts.get(token.name) ?? 0) + 1;
+		counts.set(token.name, nextCount);
+		if (nextCount > 1) {
+			const field = options.find((option) => option.name === token.name);
+			if (field) return duplicateOption(field);
+		}
+	}
+}
+async function parseCommand(command, rawArgs) {
+	let parsed;
+	try {
+		parsed = parseArgs({
+			args: [...rawArgs],
+			allowPositionals: true,
+			strict: true,
+			tokens: true,
+			options: buildParseArgsOptions(command.options)
+		});
+	} catch (error) {
+		return normalizeParseArgsError(error);
+	}
+	const duplicateError = detectDuplicateOption(command.options, parsed.tokens);
+	if (duplicateError) return duplicateError;
+	const parsedArgs = {};
+	const parsedOptions = {};
+	for (let index = 0; index < command.args.length; index += 1) {
+		const field = command.args[index];
+		const result = await parseArgumentField(field, parsed.positionals[index]);
+		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]);
+	for (const field of command.options) {
+		const rawValue = parsed.values[field.name];
+		if (rawValue !== void 0) {
+			const result = await parseOptionField(field, rawValue);
+			if (!result.ok) return result;
+			if (result.present) parsedOptions[field.name] = result.value;
+			continue;
+		}
+		const result = await resolveMissingField(field, () => missingRequiredOption(field));
+		if (!result.ok) return result;
+		if (result.present) parsedOptions[field.name] = result.value;
+	}
+	return {
+		ok: true,
+		value: {
+			options: parsedOptions,
+			args: parsedArgs,
+			rawArgs
+		}
+	};
+}
+//#endregion
+export { parseCommand as a, isSchemaField as i, executeCommand as n, formatFieldTypeHint as r, defineCommand as t };

package/dist/index-BF5_G9J2.d.mts

@@ -0,0 +1,286 @@
+//#region ../core/dist/index.d.mts
+//#region ../../node_modules/.pnpm/@standard-schema+spec@1.1.0/node_modules/@standard-schema/spec/dist/index.d.ts
+/** The Standard Typed interface. This is a base type extended by other specs. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /** The Standard Typed properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The Standard Typed types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Typed. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Typed. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** A falsy value for `issues` indicates success. */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+/** The Standard JSON Schema interface. */
+//#endregion
+//#region src/command-types.d.ts
+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. */
+  readonly name: TName;
+  /** One-line help text shown in `--help` output. */
+  readonly description?: string | undefined;
+}
+interface PrimitiveFieldBase<TName extends string, TType extends PrimitiveFieldType> extends NamedField<TName> {
+  /** Primitive type that Rune parses the raw CLI token into (`"string"`, `"number"`, or `"boolean"`). */
+  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`).
+   */
+  readonly required?: boolean | undefined;
+  /** Value used when the user does not provide this field. Makes the field always present in `ctx`. */
+  readonly default?: PrimitiveFieldValue<TType> | undefined;
+  readonly schema?: never;
+}
+interface SchemaFieldBase<TName extends string, TSchema extends StandardSchemaV1 = StandardSchemaV1> extends NamedField<TName> {
+  /**
+   * A Standard Schema object (e.g. `z.string()`, `v.number()`) used to
+   * validate and transform the raw CLI token. Required/optional and default
+   * semantics are derived from the schema itself.
+   */
+  readonly schema: TSchema;
+  readonly type?: never;
+  readonly required?: never;
+  readonly default?: never;
+}
+interface PrimitiveArgField<TName extends string = string, TType extends PrimitiveFieldType = PrimitiveFieldType> extends PrimitiveFieldBase<TName, TType> {
+  readonly alias?: never;
+  readonly flag?: never;
+}
+interface SchemaArgField<TName extends string = string, TSchema extends StandardSchemaV1 = StandardSchemaV1> extends SchemaFieldBase<TName, TSchema> {
+  readonly alias?: never;
+  readonly flag?: never;
+}
+interface PrimitiveOptionField<TName extends string = string, TType extends PrimitiveFieldType = PrimitiveFieldType> extends PrimitiveFieldBase<TName, TType> {
+  /** Single-character shorthand (e.g. `"v"` for `--verbose` → `-v`). */
+  readonly alias?: string | undefined;
+  readonly flag?: never;
+}
+interface SchemaOptionField<TName extends string = string, TSchema extends StandardSchemaV1 = StandardSchemaV1> extends SchemaFieldBase<TName, TSchema> {
+  /** Single-character shorthand (e.g. `"v"` for `--verbose` → `-v`). */
+  readonly alias?: string | undefined;
+  /**
+   * When `true`, the option is parsed as a boolean flag (no value expected).
+   * The schema receives `true` when the flag is present, `undefined` when absent.
+   */
+  readonly flag?: true | undefined;
+}
+type CommandArgField = PrimitiveArgField | SchemaArgField;
+type CommandOptionField = PrimitiveOptionField | SchemaOptionField;
+type NormalizeFields<TFields extends readonly TField[] | undefined, TField> = TFields extends readonly TField[] ? TFields : readonly [];
+type FieldName<TField> = TField extends {
+  readonly name: infer TName extends string;
+} ? TName : never;
+type InferSchemaOutput<TSchema> = TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : never;
+type InferSchemaInput<TSchema> = TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferInput<TSchema> : never;
+type IsOptionalSchemaOutput<TValue> = undefined extends TValue ? true : false;
+type FieldValue<TField> = TField extends {
+  readonly schema: infer TSchema;
+} ? Exclude<InferSchemaOutput<TSchema>, undefined> : TField extends {
+  readonly type: infer TType extends PrimitiveFieldType;
+} ? PrimitiveFieldValue<TType> : never;
+type FieldInputValue<TField> = TField extends {
+  readonly schema: infer TSchema;
+} ? InferSchemaInput<TSchema> : TField extends {
+  readonly type: infer TType extends PrimitiveFieldType;
+} ? PrimitiveFieldValue<TType> : never;
+type HasDefaultValue<TField> = TField extends {
+  readonly default: infer TDefault;
+} ? [TDefault] extends [undefined] ? false : true : false;
+type IsRequiredField<TField> = TField extends {
+  readonly schema: infer TSchema;
+} ? IsOptionalSchemaOutput<InferSchemaOutput<TSchema>> extends true ? false : true : HasDefaultValue<TField> extends true ? true : TField extends {
+  readonly required: true;
+} ? true : false;
+type IsArgOptional<TField> = TField extends {
+  readonly schema: infer TSchema;
+} ? unknown extends InferSchemaInput<TSchema> ? false : undefined extends InferSchemaInput<TSchema> ? true : false : TField extends {
+  readonly type: PrimitiveFieldType;
+} ? HasDefaultValue<TField> extends true ? true : TField extends {
+  readonly required: true;
+} ? false : true : false;
+type IsValidArgOrder<TArgs extends readonly any[], TSeenOptional extends boolean = false> = TArgs extends readonly [infer THead, ...infer TTail] ? IsArgOptional<THead> extends true ? IsValidArgOrder<TTail, true> : TSeenOptional extends true ? false : IsValidArgOrder<TTail, false> : true;
+type ValidateArgOrder<TArgs> = TArgs extends readonly CommandArgField[] ? IsValidArgOrder<TArgs> extends false ? {
+  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 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> {
+  /** Parsed and validated positional argument values keyed by field name. */
+  readonly args: TArgs;
+  /** Parsed and validated option values keyed by field name. */
+  readonly options: TOptions;
+  /** Working directory the CLI was invoked from. */
+  readonly cwd: string;
+  /**
+   * Unparsed argv tokens passed to this command, before Rune splits them
+   * into `args` and `options`. Useful for forwarding to child processes.
+   */
+  readonly rawArgs: readonly string[];
+}
+/** The command definition object accepted by {@link defineCommand}. */
+interface DefineCommandInput<TArgsFields extends readonly CommandArgField[] | undefined = undefined, TOptionsFields extends readonly CommandOptionField[] | undefined = undefined> {
+  /** One-line summary shown in `--help` output. */
+  readonly description?: string | undefined;
+  /**
+   * Positional arguments declared in the order they appear on the command line.
+   * Required arguments must come before optional ones.
+   *
+   * Each entry is either a primitive field (`{ name, type }`) or a schema
+   * field (`{ name, schema }`).
+   */
+  readonly args?: TArgsFields;
+  /**
+   * Options declared as `--name` flags, with optional single-character aliases.
+   *
+   * Each entry is either a primitive field (`{ name, type }`) or a schema
+   * field (`{ name, schema }`).
+   */
+  readonly options?: TOptionsFields;
+  /**
+   * 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>;
+}
+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>;
+} //#endregion
+//#region src/define-command.d.ts
+/**
+ * Defines a CLI command with a description, positional arguments, options,
+ * and a function to execute when the command is invoked.
+ *
+ * The command module's default export should be the return value of this function.
+ *
+ * @example
+ * ```ts
+ * export default defineCommand({
+ *   description: "Greet someone",
+ *   args: [
+ *     { name: "name", type: "string", required: true },
+ *   ],
+ *   options: [
+ *     { name: "loud", type: "boolean", alias: "l" },
+ *   ],
+ *   run(ctx) {
+ *     const greeting = `Hello, ${ctx.args.name}!`;
+ *     console.log(ctx.options.loud ? greeting.toUpperCase() : greeting);
+ *   },
+ * });
+ * ```
+ *
+ * Required positional arguments must precede optional ones. This ordering is
+ * enforced at the type level for concrete schema types and at runtime for
+ * primitive fields:
+ *
+ * ```ts
+ * // Type error — required arg after optional arg
+ * defineCommand({
+ *   args: [
+ *     { name: "source", type: "string" },
+ *     { name: "target", type: "string", required: true },
+ *   ],
+ *   run() {},
+ * });
+ *
+ * // Type error — required primitive arg after optional schema arg
+ * defineCommand({
+ *   args: [
+ *     { name: "mode", schema: z.string().optional() },
+ *     { name: "target", type: "string", required: true },
+ *   ],
+ *   run() {},
+ * });
+ * ```
+ *
+ * When a schema type is widened to plain `StandardSchemaV1` (e.g. stored in
+ * a variable without a concrete type), optionality information is lost and
+ * the ordering check is skipped for that field.
+ */
+declare function defineCommand<const TArgsFields extends readonly CommandArgField[] | undefined = undefined, const TOptionsFields extends readonly CommandOptionField[] | undefined = undefined>(input: DefineCommandInput<TArgsFields, TOptionsFields> & ValidateArgOrder<TArgsFields>): DefinedCommand<NormalizeFields<TArgsFields, CommandArgField>, NormalizeFields<TOptionsFields, CommandOptionField>>; //#endregion
+//#region src/execute-command.d.ts
+interface ExecuteCommandInput<TOptions, TArgs> {
+  readonly options?: TOptions | undefined;
+  readonly args?: TArgs | undefined;
+  readonly cwd?: string | undefined;
+  readonly rawArgs?: readonly string[] | undefined;
+}
+interface CommandExecutionResult {
+  readonly exitCode: number;
+  readonly stdout: string;
+  readonly stderr: string;
+}
+//#endregion
+export { DefinedCommand as a, PrimitiveArgField as c, SchemaArgField as d, SchemaOptionField as f, CommandOptionField as i, PrimitiveFieldType as l, CommandContext as n, ExecuteCommandInput as o, defineCommand as p, CommandExecutionResult as r, InferExecutionFields as s, CommandArgField as t, PrimitiveOptionField as u };

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { defineCommand } from "@rune-cli/core";
-export { defineCommand };
+import { a as DefinedCommand, c as PrimitiveArgField, d as SchemaArgField, f as SchemaOptionField, i as CommandOptionField, l as PrimitiveFieldType, n as CommandContext, o as ExecuteCommandInput, p as defineCommand, r as CommandExecutionResult, s as InferExecutionFields, t as CommandArgField, u as PrimitiveOptionField } from "./index-BF5_G9J2.mjs";
+export { type CommandArgField, type CommandContext, type CommandExecutionResult, 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 { defineCommand } from "@rune-cli/core";
+import { t as defineCommand } from "./dist-Bcn0FpHi.mjs";
 export { defineCommand };

package/dist/runtime.d.mts

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

package/dist/runtime.mjs

@@ -1,2 +1,2 @@
-import { n as runManifestCommand, t as writeCommandExecutionResult } from "./write-result-C0wgFsjj.mjs";
+import { n as runManifestCommand, t as writeCommandExecutionResult } from "./write-result-qylmqXvG.mjs";
 export { runManifestCommand, writeCommandExecutionResult };

package/dist/test.d.mts

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

package/dist/test.mjs

@@ -1,4 +1,4 @@
-import { executeCommand } from "@rune-cli/core";
+import { n as executeCommand } from "./dist-Bcn0FpHi.mjs";
 //#region src/test.ts
 async function runCommand(command, options = {}) {
 	return executeCommand(command, options);

package/dist/{write-result-C0wgFsjj.mjs → write-result-qylmqXvG.mjs}

@@ -1,4 +1,4 @@
-import { executeCommand, formatFieldTypeHint, isSchemaField, parseCommand } from "@rune-cli/core";
+import { a as parseCommand, i as isSchemaField, n as executeCommand, r as formatFieldTypeHint } from "./dist-Bcn0FpHi.mjs";
 import { pathToFileURL } from "node:url";
 //#region src/cli/result.ts
 function successResult(stdout) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rune-cli/rune",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Rune is a CLI framework built around the concept of file-based command routing.",
   "homepage": "https://github.com/morinokami/rune#readme",
   "bugs": {
@@ -39,15 +39,14 @@
     "access": "public"
   },
   "dependencies": {
-    "esbuild": "0.27.4",
-    "@rune-cli/core": "0.0.0"
+    "esbuild": "0.27.4"
   },
   "devDependencies": {
     "@types/node": "24.12.0",
     "@typescript/native-preview": "7.0.0-dev.20260317.1",
-    "bumpp": "11.0.1",
     "typescript": "5.9.3",
-    "vite-plus": "v0.1.13"
+    "vite-plus": "v0.1.13",
+    "@rune-cli/core": "0.0.0"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0"