@rune-cli/rune 0.0.9 → 0.0.11

package/dist/test.mjs

@@ -1,42 +1,91 @@
-import { r as executeCommand, t as captureProcessOutput } from "./dist-DuisScgY.mjs";
-//#region src/test.ts
-/**
-* Runs a command definition directly in-process for testing.
-*
-* This helper bypasses Rune's CLI parser and validation layers. Callers
-* provide already-normalized `options` and `args` values, and the command's
-* `run` function is executed with those values injected into the context.
-*
-* All output written to `process.stdout`, `process.stderr`, and `console` is
-* captured and returned as strings so tests can assert on them.
-*
-* @param command - A command created with {@link defineCommand}.
-* @param options - Pre-validated options, args, cwd, and rawArgs to inject.
-* @returns The exit code, captured stdout/stderr, and an optional error message.
-*
-* @example
-* ```ts
-* import { defineCommand } from "rune";
-* import { runCommand } from "rune/test";
-* import { expect, test } from "vitest";
-*
-* const hello = defineCommand({
-*   options: [{ name: "name", type: "string", required: true }],
-*   run(ctx) {
-*     console.log(`Hello, ${ctx.options.name}!`);
-*   },
-* });
-*
-* test("hello command", async () => {
-*   const result = await runCommand(hello, {
-*     options: { name: "Rune" },
-*   });
-*
-*   expect(result.exitCode).toBe(0);
-*   expect(result.stdout).toBe("Hello, Rune!\n");
-* });
-* ```
-*/
+import { format } from "node:util";
+//#region ../test-utils/dist/index.mjs
+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 {
+		return {
+			ok: true,
+			value: await action(),
+			stdout: stdoutChunks.join(""),
+			stderr: stderrChunks.join("")
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error,
+			stdout: stdoutChunks.join(""),
+			stderr: stderrChunks.join("")
+		};
+	} finally {
+		process.stdout.write = originalStdoutWrite;
+		process.stderr.write = originalStderrWrite;
+		Object.assign(console, originalConsoleMethods);
+	}
+}
+function isSchemaField(field) {
+	return "schema" in field && field.schema !== void 0;
+}
+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";
+}
+function createExecutionOptions(command, input) {
+	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;
+	return options;
+}
+async function executeCommand(command, input = {}) {
+	try {
+		await command.run({
+			options: createExecutionOptions(command, input),
+			args: input.args ?? {},
+			cwd: input.cwd ?? process.cwd(),
+			rawArgs: input.rawArgs ?? []
+		});
+		return { exitCode: 0 };
+	} catch (error) {
+		const message = formatExecutionError(error);
+		return message ? {
+			exitCode: 1,
+			errorMessage: message
+		} : { exitCode: 1 };
+	}
+}
 async function runCommand(command, options = {}) {
 	const captured = await captureProcessOutput(() => executeCommand(command, options));
 	if (!captured.ok) throw captured.error;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rune-cli/rune",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "Rune is a CLI framework built around the concept of file-based command routing.",
   "homepage": "https://github.com/morinokami/rune#readme",
   "bugs": {
@@ -46,7 +46,8 @@
     "@typescript/native-preview": "7.0.0-dev.20260322.1",
     "typescript": "5.9.3",
     "vite-plus": "v0.1.13",
-    "@rune-cli/core": "0.0.0"
+    "@rune-cli/core": "0.0.0",
+    "@rune-cli/test-utils": "0.0.0"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0"