@rune-cli/rune 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shinya Fujino
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,492 @@
+#!/usr/bin/env node
+import { i as successResult, n as runManifestCommand, r as failureResult, t as writeCommandExecutionResult } from "./write-result-C0wgFsjj.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 src/manifest/generate-manifest.ts
+const COMMAND_ENTRY_FILE = "index.ts";
+function comparePathSegments(left, right) {
+	const length = Math.min(left.length, right.length);
+	for (let index = 0; index < length; index += 1) {
+		const comparison = left[index].localeCompare(right[index]);
+		if (comparison !== 0) return comparison;
+	}
+	return left.length - right.length;
+}
+function getPropertyNameText(name) {
+	if (ts.isIdentifier(name) || ts.isStringLiteral(name)) return name.text;
+}
+function getStaticDescriptionValue(expression) {
+	if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)) return expression.text;
+}
+function isDefineCommandExpression(expression) {
+	if (ts.isIdentifier(expression)) return expression.text === "defineCommand";
+	if (ts.isPropertyAccessExpression(expression)) return expression.name.text === "defineCommand";
+	return false;
+}
+function extractDescriptionFromCommandDefinition(expression, knownDescriptions) {
+	if (ts.isIdentifier(expression)) return knownDescriptions.get(expression.text);
+	if (!ts.isCallExpression(expression) || !isDefineCommandExpression(expression.expression)) return;
+	const [definition] = expression.arguments;
+	if (!definition || !ts.isObjectLiteralExpression(definition)) return;
+	for (const property of definition.properties) {
+		if (!ts.isPropertyAssignment(property)) continue;
+		if (getPropertyNameText(property.name) !== "description") continue;
+		return getStaticDescriptionValue(property.initializer);
+	}
+}
+async function extractDescriptionFromSourceFile(sourceFilePath) {
+	const sourceText = await readFile(sourceFilePath, "utf8");
+	const sourceFile = ts.createSourceFile(sourceFilePath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const knownDescriptions = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if (ts.isVariableStatement(statement)) {
+			for (const declaration of statement.declarationList.declarations) {
+				if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
+				knownDescriptions.set(declaration.name.text, extractDescriptionFromCommandDefinition(declaration.initializer, knownDescriptions));
+			}
+			continue;
+		}
+		if (ts.isExportAssignment(statement)) return extractDescriptionFromCommandDefinition(statement.expression, knownDescriptions);
+	}
+}
+async function walkCommandsDirectory(absoluteDirectoryPath, pathSegments, extractDescription) {
+	const entries = await readdir(absoluteDirectoryPath, { withFileTypes: true });
+	const childDirectoryNames = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
+	const childResults = await Promise.all(childDirectoryNames.map(async (directoryName) => {
+		return {
+			directoryName,
+			result: await walkCommandsDirectory(path.join(absoluteDirectoryPath, directoryName), [...pathSegments, directoryName], extractDescription)
+		};
+	}));
+	const childNodes = childResults.flatMap(({ result }) => result.nodes);
+	const childNames = childResults.filter(({ result }) => result.hasNode).map(({ directoryName }) => directoryName);
+	const hasCommandEntry = entries.some((entry) => entry.isFile() && entry.name === COMMAND_ENTRY_FILE);
+	if (!hasCommandEntry && childNames.length === 0) return {
+		nodes: childNodes,
+		hasNode: false
+	};
+	let node;
+	if (hasCommandEntry) {
+		const sourceFilePath = path.join(absoluteDirectoryPath, COMMAND_ENTRY_FILE);
+		node = {
+			pathSegments,
+			kind: "command",
+			sourceFilePath,
+			childNames,
+			description: await extractDescription(sourceFilePath)
+		};
+	} else node = {
+		pathSegments,
+		kind: "group",
+		childNames
+	};
+	return {
+		nodes: [node, ...childNodes],
+		hasNode: true
+	};
+}
+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)) };
+}
+function serializeCommandManifest(manifest) {
+	return JSON.stringify(manifest, null, 2);
+}
+//#endregion
+//#region src/project/project-files.ts
+const SOURCE_DIRECTORY_NAME = "src";
+const COMMANDS_DIRECTORY_NAME = path.join(SOURCE_DIRECTORY_NAME, "commands");
+const DIST_DIRECTORY_NAME = "dist";
+function resolveProjectPath(options) {
+	const baseDirectory = options.cwd ?? process.cwd();
+	return path.resolve(baseDirectory, options.projectPath ?? ".");
+}
+function resolveSourceDirectory(projectRoot) {
+	return path.join(projectRoot, SOURCE_DIRECTORY_NAME);
+}
+function resolveCommandsDirectory(projectRoot) {
+	return path.join(projectRoot, COMMANDS_DIRECTORY_NAME);
+}
+function resolveDistDirectory(projectRoot) {
+	return path.join(projectRoot, DIST_DIRECTORY_NAME);
+}
+async function readProjectCliName(projectRoot) {
+	const packageJsonPath = path.join(projectRoot, "package.json");
+	try {
+		const packageJsonContents = await readFile(packageJsonPath, "utf8");
+		const packageJson = JSON.parse(packageJsonContents);
+		if (packageJson.bin && typeof packageJson.bin === "object") {
+			const binNames = Object.keys(packageJson.bin).sort((left, right) => left.localeCompare(right));
+			if (binNames.length > 0) return binNames[0];
+		}
+		if (packageJson.name && packageJson.name.length > 0) return packageJson.name.split("/").at(-1) ?? packageJson.name;
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	return path.basename(projectRoot);
+}
+async function assertCommandsDirectoryExists(commandsDirectory) {
+	if (!(await stat(commandsDirectory).catch((error) => {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}))?.isDirectory()) throw new Error(`Commands directory not found: ${commandsDirectory}`);
+}
+//#endregion
+//#region src/cli/build-command.ts
+const BUILD_CLI_FILENAME = "cli.mjs";
+const BUILD_MANIFEST_FILENAME = "manifest.json";
+const RUNE_PACKAGE_NAME = "@rune-cli/rune";
+const CODE_SOURCE_EXTENSIONS = new Set([
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+]);
+const BUILD_TARGET = "node24";
+function isCodeSourceFile(filePath) {
+	return CODE_SOURCE_EXTENSIONS.has(path.extname(filePath));
+}
+function isDeclarationFile(filePath) {
+	return filePath.endsWith(".d.ts") || filePath.endsWith(".d.mts") || filePath.endsWith(".d.cts");
+}
+function replaceFileExtension(filePath, extension) {
+	const parsedPath = path.parse(filePath);
+	return path.join(parsedPath.dir, `${parsedPath.name}${extension}`);
+}
+function toPosixPath(filePath) {
+	return filePath.split(path.sep).join(path.posix.sep);
+}
+function createBuiltManifest(manifest, sourceDirectory) {
+	return { nodes: manifest.nodes.map((node) => {
+		if (node.kind !== "command") return node;
+		const relativeSourceFilePath = path.relative(sourceDirectory, node.sourceFilePath);
+		return {
+			...node,
+			sourceFilePath: toPosixPath(replaceFileExtension(relativeSourceFilePath, ".mjs"))
+		};
+	}) };
+}
+function isBuildFailure(error) {
+	return typeof error === "object" && error !== null && "errors" in error && Array.isArray(error.errors);
+}
+function formatBuildFailure(projectRoot, error) {
+	const [firstError] = error.errors;
+	if (!firstError) return "Failed to build project";
+	if (!firstError.location) return `Failed to compile: ${firstError.text}`;
+	return `Failed to compile ${path.isAbsolute(firstError.location.file) ? path.relative(projectRoot, firstError.location.file) : firstError.location.file}:${firstError.location.line}:${firstError.location.column + 1}: ${firstError.text}`;
+}
+async function copyBuiltAssets(sourceDirectory, distDirectory) {
+	const entries = await readdir(sourceDirectory, { withFileTypes: true });
+	await Promise.all(entries.map(async (entry) => {
+		const sourceEntryPath = path.join(sourceDirectory, entry.name);
+		const distEntryPath = path.join(distDirectory, entry.name);
+		if (entry.isDirectory()) {
+			await copyBuiltAssets(sourceEntryPath, distEntryPath);
+			return;
+		}
+		if (isDeclarationFile(sourceEntryPath)) return;
+		if (isCodeSourceFile(sourceEntryPath)) return;
+		await mkdir(path.dirname(distEntryPath), { recursive: true });
+		await cp(sourceEntryPath, distEntryPath);
+	}));
+}
+function renderBuiltCliEntry(cliName, runtimeImportPath) {
+	return `import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+import { runManifestCommand, writeCommandExecutionResult } from ${JSON.stringify(runtimeImportPath)};
+
+const cliName = ${JSON.stringify(cliName)};
+const distDirectoryUrl = new URL("./", import.meta.url);
+const manifestPath = fileURLToPath(new URL("./${BUILD_MANIFEST_FILENAME}", distDirectoryUrl));
+const manifestContents = await readFile(manifestPath, "utf8");
+const manifest = JSON.parse(manifestContents);
+const runtimeManifest = {
+  ...manifest,
+  nodes: manifest.nodes.map((node) =>
+    node.kind === "command"
+      ? {
+          ...node,
+          sourceFilePath: fileURLToPath(new URL(node.sourceFilePath, distDirectoryUrl)),
+        }
+      : node,
+  ),
+};
+const result = await runManifestCommand({
+  manifest: runtimeManifest,
+  rawArgs: process.argv.slice(2),
+  cliName,
+  cwd: process.cwd(),
+});
+
+await writeCommandExecutionResult(result);
+`;
+}
+function collectCommandEntryPoints(manifest) {
+	return manifest.nodes.flatMap((node) => node.kind === "command" ? [node.sourceFilePath] : []);
+}
+async function pathExists(filePath) {
+	try {
+		return (await stat(filePath)).isFile();
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+async function resolveRunePackageRoot() {
+	let currentDirectory = path.dirname(fileURLToPath(import.meta.url));
+	while (true) {
+		const packageJsonPath = path.join(currentDirectory, "package.json");
+		try {
+			if (JSON.parse(await readFile(packageJsonPath, "utf8")).name === RUNE_PACKAGE_NAME) return currentDirectory;
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		const parentDirectory = path.dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) throw new Error(`Could not locate package root for ${RUNE_PACKAGE_NAME}`);
+		currentDirectory = parentDirectory;
+	}
+}
+async function resolveBuildTsconfig(projectRoot) {
+	const tsconfigPath = path.join(projectRoot, "tsconfig.json");
+	return await pathExists(tsconfigPath) ? tsconfigPath : void 0;
+}
+async function resolveRuntimeHelperEntryPath() {
+	const packageRoot = await resolveRunePackageRoot();
+	const sourceRuntimePath = path.join(packageRoot, "src", "runtime.ts");
+	if (await pathExists(sourceRuntimePath)) return sourceRuntimePath;
+	const distRuntimePath = path.join(packageRoot, "dist", "runtime.mjs");
+	if (await pathExists(distRuntimePath)) return distRuntimePath;
+	throw new Error("Could not locate Rune runtime helper entry");
+}
+async function buildCommandEntries(projectRoot, sourceDirectory, distDirectory, manifest) {
+	const entryPoints = [...collectCommandEntryPoints(manifest)];
+	const tsconfig = await resolveBuildTsconfig(projectRoot);
+	if (entryPoints.length === 0) return;
+	await build({
+		absWorkingDir: projectRoot,
+		entryPoints,
+		outdir: distDirectory,
+		outbase: sourceDirectory,
+		entryNames: "[dir]/[name]",
+		chunkNames: "chunks/[name]-[hash]",
+		assetNames: "assets/[name]-[hash]",
+		bundle: true,
+		format: "esm",
+		platform: "node",
+		target: BUILD_TARGET,
+		splitting: true,
+		tsconfig,
+		outExtension: { ".js": ".mjs" },
+		logLevel: "silent",
+		write: true
+	});
+}
+async function buildCliEntry(projectRoot, distDirectory, cliName) {
+	const runtimeHelperEntryPath = await resolveRuntimeHelperEntryPath();
+	await build({
+		absWorkingDir: projectRoot,
+		stdin: {
+			contents: renderBuiltCliEntry(cliName, `./${path.basename(runtimeHelperEntryPath)}`),
+			loader: "ts",
+			resolveDir: path.dirname(runtimeHelperEntryPath),
+			sourcefile: "rune-built-cli-entry.ts"
+		},
+		outfile: path.join(distDirectory, BUILD_CLI_FILENAME),
+		bundle: true,
+		format: "esm",
+		platform: "node",
+		target: BUILD_TARGET,
+		banner: { js: "#!/usr/bin/env node" },
+		logLevel: "silent",
+		write: true
+	});
+}
+async function writeBuiltRuntimeFiles(distDirectory, manifest) {
+	await mkdir(distDirectory, { recursive: true });
+	await writeFile(path.join(distDirectory, BUILD_MANIFEST_FILENAME), serializeCommandManifest(manifest));
+}
+async function runBuildCommand(options) {
+	let projectRoot = "";
+	try {
+		projectRoot = resolveProjectPath(options);
+		const sourceDirectory = resolveSourceDirectory(projectRoot);
+		const commandsDirectory = resolveCommandsDirectory(projectRoot);
+		const distDirectory = resolveDistDirectory(projectRoot);
+		await assertCommandsDirectoryExists(commandsDirectory);
+		const sourceManifest = await generateCommandManifest({ commandsDirectory });
+		const builtManifest = createBuiltManifest(sourceManifest, sourceDirectory);
+		const cliName = await readProjectCliName(projectRoot);
+		await rm(distDirectory, {
+			recursive: true,
+			force: true
+		});
+		await writeBuiltRuntimeFiles(distDirectory, builtManifest);
+		await Promise.all([
+			buildCommandEntries(projectRoot, sourceDirectory, distDirectory, sourceManifest),
+			buildCliEntry(projectRoot, distDirectory, cliName),
+			copyBuiltAssets(sourceDirectory, distDirectory)
+		]);
+		return successResult(`Built CLI to ${path.join(distDirectory, BUILD_CLI_FILENAME)}\n`);
+	} catch (error) {
+		if (isBuildFailure(error)) return failureResult(formatBuildFailure(projectRoot, error));
+		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";
+const DEV_MANIFEST_FILENAME = "manifest.json";
+async function writeDevManifest(projectRoot, manifestContents) {
+	const manifestDirectory = path.join(projectRoot, DEV_MANIFEST_DIRECTORY_PATH);
+	const manifestPath = path.join(manifestDirectory, DEV_MANIFEST_FILENAME);
+	await mkdir(manifestDirectory, { recursive: true });
+	await writeFile(manifestPath, manifestContents);
+}
+async function runDevCommand(options) {
+	try {
+		const projectRoot = resolveProjectPath(options);
+		const commandsDirectory = resolveCommandsDirectory(projectRoot);
+		await assertCommandsDirectoryExists(commandsDirectory);
+		const manifest = await generateCommandManifest({ commandsDirectory });
+		await writeDevManifest(projectRoot, serializeCommandManifest(manifest));
+		return runManifestCommand({
+			manifest,
+			rawArgs: options.rawArgs,
+			cliName: await readProjectCliName(projectRoot),
+			cwd: options.cwd
+		});
+	} catch (error) {
+		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) {
+	const token = argv[index];
+	if (token.startsWith("--project=")) return {
+		projectPath: token.slice(10),
+		nextIndex: index + 1
+	};
+	if (token === "--project") {
+		const nextToken = argv[index + 1];
+		if (!nextToken) return failureResult("Missing value for --project");
+		return {
+			projectPath: nextToken,
+			nextIndex: index + 2
+		};
+	}
+}
+function isHelpFlag(token) {
+	return token === "--help" || token === "-h";
+}
+function parseDevArgs(argv) {
+	const commandArgs = [];
+	let projectPath;
+	for (let index = 0; index < argv.length; index += 1) {
+		const token = argv[index];
+		if (token === "--") {
+			commandArgs.push(...argv.slice(index + 1));
+			return {
+				projectPath,
+				commandArgs
+			};
+		}
+		if (isHelpFlag(token)) return successResult(renderRuneDevHelp());
+		const projectResult = tryParseProjectOption(argv, index);
+		if (projectResult) {
+			if ("exitCode" in projectResult) return projectResult;
+			projectPath = projectResult.projectPath;
+			index = projectResult.nextIndex - 1;
+			continue;
+		}
+		commandArgs.push(token, ...argv.slice(index + 1));
+		return {
+			projectPath,
+			commandArgs
+		};
+	}
+	return {
+		projectPath,
+		commandArgs
+	};
+}
+function parseBuildArgs(argv) {
+	let projectPath;
+	for (let index = 0; index < argv.length; index += 1) {
+		const token = argv[index];
+		if (isHelpFlag(token)) return successResult(renderRuneBuildHelp());
+		const projectResult = tryParseProjectOption(argv, index);
+		if (projectResult) {
+			if ("exitCode" in projectResult) return projectResult;
+			projectPath = projectResult.projectPath;
+			index = projectResult.nextIndex - 1;
+			continue;
+		}
+		return failureResult(`Unexpected argument for rune build: ${token}`);
+	}
+	return { projectPath };
+}
+async function runRuneCli(options) {
+	const [subcommand, ...restArgs] = options.argv;
+	if (!subcommand || isHelpFlag(subcommand)) return successResult(renderRuneCliHelp());
+	if (subcommand === "dev") {
+		const parsedDevArgs = parseDevArgs(restArgs);
+		if ("exitCode" in parsedDevArgs) return parsedDevArgs;
+		return runDevCommand({
+			rawArgs: parsedDevArgs.commandArgs,
+			projectPath: parsedDevArgs.projectPath,
+			cwd: options.cwd
+		});
+	}
+	if (subcommand === "build") {
+		const parsedBuildArgs = parseBuildArgs(restArgs);
+		if ("exitCode" in parsedBuildArgs) return parsedBuildArgs;
+		return runBuildCommand({
+			projectPath: parsedBuildArgs.projectPath,
+			cwd: options.cwd
+		});
+	}
+	return failureResult(`Unknown rune command: ${subcommand}`);
+}
+//#endregion
+//#region src/cli.ts
+await writeCommandExecutionResult(await runRuneCli({
+	argv: process.argv.slice(2),
+	cwd: process.cwd()
+}));
+//#endregion
+export {};

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+import { defineCommand } from "@rune-cli/core";
+export { defineCommand };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { defineCommand } from "@rune-cli/core";
+export { defineCommand };

package/dist/runtime.d.mts

@@ -0,0 +1,41 @@
+import { CommandArgField, CommandExecutionResult, CommandOptionField, DefinedCommand } from "@rune-cli/core";
+
+//#region src/manifest/manifest-types.d.ts
+type CommandManifestPath = readonly string[];
+type CommandManifestNodeKind = "command" | "group";
+interface CommandManifestNodeBase {
+  readonly pathSegments: CommandManifestPath;
+  readonly kind: CommandManifestNodeKind;
+  readonly childNames: readonly string[];
+  readonly description?: string | undefined;
+}
+interface CommandManifestCommandNode extends CommandManifestNodeBase {
+  readonly kind: "command";
+  readonly sourceFilePath: string;
+}
+interface CommandManifestGroupNode extends CommandManifestNodeBase {
+  readonly kind: "group";
+  readonly sourceFilePath?: undefined;
+}
+type CommandManifestNode = CommandManifestCommandNode | CommandManifestGroupNode;
+interface CommandManifest {
+  readonly nodes: readonly CommandManifestNode[];
+}
+//#endregion
+//#region src/manifest/render-help.d.ts
+type LoadCommandFn = (node: CommandManifestCommandNode) => Promise<DefinedCommand<readonly CommandArgField[], readonly CommandOptionField[]>>;
+//#endregion
+//#region src/manifest/run-manifest-command.d.ts
+interface RunManifestCommandOptions {
+  readonly manifest: CommandManifest;
+  readonly rawArgs: readonly string[];
+  readonly cliName: string;
+  readonly cwd?: string | undefined;
+  readonly loadCommand?: LoadCommandFn | undefined;
+}
+declare function runManifestCommand(options: RunManifestCommandOptions): Promise<CommandExecutionResult>;
+//#endregion
+//#region src/cli/write-result.d.ts
+declare function writeCommandExecutionResult(result: CommandExecutionResult): Promise<void>;
+//#endregion
+export { runManifestCommand, writeCommandExecutionResult };

package/dist/runtime.mjs

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

package/dist/test.d.mts

@@ -0,0 +1,7 @@
+import { CommandArgField, CommandExecutionResult, CommandOptionField, DefinedCommand, ExecuteCommandInput, InferExecutionFields } from "@rune-cli/core";
+
+//#region src/test.d.ts
+type RunCommandOptions<TOptions, TArgs> = ExecuteCommandInput<TOptions, TArgs>;
+declare function runCommand<TArgsFields extends readonly CommandArgField[], TOptionsFields extends readonly CommandOptionField[]>(command: DefinedCommand<TArgsFields, TOptionsFields>, options?: RunCommandOptions<InferExecutionFields<TOptionsFields>, InferExecutionFields<TArgsFields>>): Promise<CommandExecutionResult>;
+//#endregion
+export { RunCommandOptions, runCommand };

package/dist/test.mjs

@@ -0,0 +1,7 @@
+import { executeCommand } from "@rune-cli/core";
+//#region src/test.ts
+async function runCommand(command, options = {}) {
+	return executeCommand(command, options);
+}
+//#endregion
+export { runCommand };

package/dist/write-result-C0wgFsjj.mjs

@@ -0,0 +1,225 @@
+import { executeCommand, formatFieldTypeHint, isSchemaField, parseCommand } from "@rune-cli/core";
+import { pathToFileURL } from "node:url";
+//#region src/cli/result.ts
+function successResult(stdout) {
+	return {
+		exitCode: 0,
+		stdout,
+		stderr: ""
+	};
+}
+function failureResult(stderr) {
+	return {
+		exitCode: 1,
+		stdout: "",
+		stderr: stderr.endsWith("\n") ? stderr : `${stderr}\n`
+	};
+}
+//#endregion
+//#region src/manifest/manifest-map.ts
+function commandManifestPathToKey(pathSegments) {
+	return pathSegments.join(" ");
+}
+function createCommandManifestNodeMap(manifest) {
+	return Object.fromEntries(manifest.nodes.map((node) => [commandManifestPathToKey(node.pathSegments), node]));
+}
+//#endregion
+//#region src/manifest/render-help.ts
+async function loadCommandFromModule(sourceFilePath) {
+	const loadedModule = await import(pathToFileURL(sourceFilePath).href);
+	if (loadedModule.default === void 0) throw new Error(`Command module did not export a default command: ${sourceFilePath}`);
+	return loadedModule.default;
+}
+const defaultLoadCommand = (node) => loadCommandFromModule(node.sourceFilePath);
+function formatCommandName(cliName, pathSegments) {
+	return pathSegments.length === 0 ? cliName : `${cliName} ${pathSegments.join(" ")}`;
+}
+function formatSectionEntries(entries) {
+	return entries.map(({ label, description }) => `  ${label}${description ? `  ${description}` : ""}`).join("\n");
+}
+function formatArgumentLabel(field) {
+	return `${field.name}${formatFieldTypeHint(field)}`;
+}
+function formatOptionLabel(field) {
+	const longOptionLabel = `--${field.name}${formatFieldTypeHint(field)}`;
+	if (!field.alias) return longOptionLabel;
+	return `-${field.alias}, ${longOptionLabel}`;
+}
+async function isFieldRequired(field) {
+	if (!isSchemaField(field)) return field.required === true && field.default === void 0;
+	return !("value" in await field.schema["~standard"].validate(void 0));
+}
+async function formatUsageArguments(fields) {
+	const usageParts = [];
+	for (const field of fields) {
+		const required = await isFieldRequired(field);
+		usageParts.push(required ? `<${field.name}>` : `[${field.name}]`);
+	}
+	return usageParts.join(" ");
+}
+function getOptionUsageSuffix(fields) {
+	return fields.length === 0 ? "" : "[options]";
+}
+function renderGroupHelp(manifest, node, cliName) {
+	const nodeMap = createCommandManifestNodeMap(manifest);
+	const entries = node.childNames.map((childName) => {
+		return {
+			label: childName,
+			description: nodeMap[commandManifestPathToKey([...node.pathSegments, childName])]?.description
+		};
+	});
+	const parts = [`Usage: ${formatCommandName(cliName, node.pathSegments)} <command>`];
+	if (entries.length > 0) parts.push(`Subcommands:\n${formatSectionEntries(entries)}`);
+	return `${parts.join("\n\n")}\n`;
+}
+async function renderCommandHelp(command, pathSegments, cliName) {
+	const usageArguments = await formatUsageArguments(command.args);
+	const optionUsageSuffix = getOptionUsageSuffix(command.options);
+	const parts = [`Usage: ${[
+		formatCommandName(cliName, pathSegments),
+		usageArguments,
+		optionUsageSuffix
+	].filter((part) => part.length > 0).join(" ")}`];
+	if (command.description) parts.push(`Description:\n  ${command.description}`);
+	if (command.args.length > 0) parts.push(`Arguments:\n${formatSectionEntries(command.args.map((field) => ({
+		label: formatArgumentLabel(field),
+		description: field.description
+	})))}`);
+	const optionEntries = [...command.options.map((field) => ({
+		label: formatOptionLabel(field),
+		description: field.description
+	})), {
+		label: "-h, --help",
+		description: "Show help"
+	}];
+	parts.push(`Options:\n${formatSectionEntries(optionEntries)}`);
+	return `${parts.join("\n\n")}\n`;
+}
+function renderUnknownCommandMessage(route, cliName) {
+	const parts = [`Unknown command: ${formatCommandName(cliName, route.attemptedPath)}`];
+	if (route.suggestions.length > 0) parts.push(`Did you mean?\n${route.suggestions.map((name) => `  ${name}`).join("\n")}`);
+	return `${parts.join("\n\n")}\n`;
+}
+async function renderResolvedHelp(options) {
+	if (options.route.kind === "unknown") return renderUnknownCommandMessage(options.route, options.cliName);
+	if (options.route.kind === "group") return renderGroupHelp(options.manifest, options.route.node, options.cliName);
+	return renderCommandHelp(await (options.loadCommand ?? defaultLoadCommand)(options.route.node), options.route.matchedPath, options.cliName);
+}
+//#endregion
+//#region src/manifest/damerau-levenshtein.ts
+function damerauLevenshteinDistance(left, right) {
+	const rows = left.length + 1;
+	const cols = right.length + 1;
+	const matrix = Array.from({ length: rows }, () => Array(cols).fill(0));
+	for (let row = 0; row < rows; row += 1) matrix[row][0] = row;
+	for (let col = 0; col < cols; col += 1) matrix[0][col] = col;
+	for (let row = 1; row < rows; row += 1) for (let col = 1; col < cols; col += 1) {
+		const substitutionCost = left[row - 1] === right[col - 1] ? 0 : 1;
+		matrix[row][col] = Math.min(matrix[row - 1][col] + 1, matrix[row][col - 1] + 1, matrix[row - 1][col - 1] + substitutionCost);
+		if (row > 1 && col > 1 && left[row - 1] === right[col - 2] && left[row - 2] === right[col - 1]) matrix[row][col] = Math.min(matrix[row][col], matrix[row - 2][col - 2] + 1);
+	}
+	return matrix[left.length][right.length];
+}
+//#endregion
+//#region src/manifest/resolve-command-path.ts
+function isOptionLikeToken(token) {
+	return token === "--" || token.startsWith("-");
+}
+function getHelpRequested(args) {
+	return args.includes("--help") || args.includes("-h");
+}
+function getSuggestionThreshold(candidate) {
+	return Math.max(2, Math.floor(candidate.length / 3));
+}
+function getSuggestedChildNames(unknownSegment, childNames) {
+	return [...childNames].map((childName) => ({
+		childName,
+		distance: damerauLevenshteinDistance(unknownSegment, childName)
+	})).filter(({ childName, distance }) => distance <= getSuggestionThreshold(childName)).sort((left, right) => left.distance - right.distance || left.childName.localeCompare(right.childName)).slice(0, 3).map(({ childName }) => childName);
+}
+function resolveCommandPath(manifest, rawArgs) {
+	const nodeMap = createCommandManifestNodeMap(manifest);
+	const rootNode = nodeMap[""];
+	if (rootNode === void 0) throw new Error("Manifest root node is missing");
+	let currentNode = rootNode;
+	let tokenIndex = 0;
+	while (tokenIndex < rawArgs.length) {
+		const token = rawArgs[tokenIndex];
+		if (isOptionLikeToken(token)) break;
+		const childNode = nodeMap[commandManifestPathToKey([...currentNode.pathSegments, token])];
+		if (childNode === void 0) {
+			const suggestions = getSuggestedChildNames(token, currentNode.childNames);
+			if (currentNode.kind === "group" || suggestions.length > 0) return {
+				kind: "unknown",
+				attemptedPath: [...currentNode.pathSegments, token],
+				matchedPath: currentNode.pathSegments,
+				unknownSegment: token,
+				availableChildNames: currentNode.childNames,
+				suggestions
+			};
+			break;
+		}
+		currentNode = childNode;
+		tokenIndex += 1;
+	}
+	const remainingArgs = rawArgs.slice(tokenIndex);
+	const helpRequested = getHelpRequested(remainingArgs);
+	if (currentNode.kind === "group") return {
+		kind: "group",
+		node: currentNode,
+		matchedPath: currentNode.pathSegments,
+		remainingArgs,
+		helpRequested
+	};
+	return {
+		kind: "command",
+		node: currentNode,
+		matchedPath: currentNode.pathSegments,
+		remainingArgs,
+		helpRequested
+	};
+}
+//#endregion
+//#region src/manifest/run-manifest-command.ts
+async function runManifestCommand(options) {
+	const route = resolveCommandPath(options.manifest, options.rawArgs);
+	if (route.kind === "unknown" || route.kind === "group" || route.helpRequested) {
+		const output = await renderResolvedHelp({
+			manifest: options.manifest,
+			route,
+			cliName: options.cliName,
+			loadCommand: options.loadCommand
+		});
+		return route.kind === "unknown" ? failureResult(output) : successResult(output);
+	}
+	const command = await (options.loadCommand ?? defaultLoadCommand)(route.node);
+	const parsed = await parseCommand(command, route.remainingArgs);
+	if (!parsed.ok) return failureResult(parsed.error.message);
+	return executeCommand(command, {
+		options: parsed.value.options,
+		args: parsed.value.args,
+		cwd: options.cwd,
+		rawArgs: parsed.value.rawArgs
+	});
+}
+//#endregion
+//#region src/cli/write-result.ts
+async function writeStream(stream, contents) {
+	if (contents.length === 0) return;
+	await new Promise((resolve, reject) => {
+		stream.write(contents, (error) => {
+			if (error) {
+				reject(error);
+				return;
+			}
+			resolve();
+		});
+	});
+}
+async function writeCommandExecutionResult(result) {
+	await writeStream(process.stdout, result.stdout);
+	await writeStream(process.stderr, result.stderr);
+	process.exitCode = result.exitCode;
+}
+//#endregion
+export { successResult as i, runManifestCommand as n, failureResult as r, writeCommandExecutionResult as t };

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@rune-cli/rune",
+  "version": "0.0.1",
+  "description": "Rune is a CLI framework built around the concept of file-based command routing.",
+  "homepage": "https://github.com/morinokami/rune#readme",
+  "bugs": {
+    "url": "https://github.com/morinokami/rune/issues"
+  },
+  "license": "MIT",
+  "author": "Shinya Fujino <shf0811@gmail.com> (https://github.com/morinokami)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/morinokami/rune.git",
+    "directory": "packages/rune"
+  },
+  "bin": {
+    "rune": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./cli": {
+      "types": "./dist/cli.d.mts",
+      "import": "./dist/cli.mjs"
+    },
+    "./test": {
+      "types": "./dist/test.d.mts",
+      "import": "./dist/test.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "esbuild": "0.27.4",
+    "@rune-cli/core": "0.0.0"
+  },
+  "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"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "engines": {
+    "node": ">=24.12.0"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
+  }
+}