@reckona/create-mreact-app 0.0.93 → 0.0.95

package/src/prompts.ts

@@ -0,0 +1,188 @@
+import { createInterface, emitKeypressEvents, type Key } from "node:readline";
+
+/**
+ * Minimal, dependency-free interactive prompts built on Node's `node:readline`.
+ *
+ * All functions accept `input`/`output` streams so they can be driven by
+ * in-memory streams (e.g. `PassThrough`) in tests without mocking.
+ */
+
+interface PromptStreamControls {
+  isTTY?: boolean;
+  pause?: () => void;
+  resume?: () => void;
+  setRawMode?: (mode: boolean) => void;
+}
+
+type PromptReadable = NodeJS.ReadableStream & PromptStreamControls;
+type PromptWritable = NodeJS.WritableStream;
+
+export interface TextOptions {
+  defaultValue: string;
+  input?: PromptReadable | undefined;
+  message: string;
+  output?: PromptWritable | undefined;
+}
+
+export interface SelectChoice<T> {
+  hint?: string | undefined;
+  label: string;
+  value: T;
+}
+
+export interface SelectOptions<T> {
+  choices: ReadonlyArray<SelectChoice<T>>;
+  initialIndex?: number | undefined;
+  input?: PromptReadable | undefined;
+  message: string;
+  output?: PromptWritable | undefined;
+}
+
+/** Create the error used to signal that the user aborted a prompt (Ctrl+C). */
+export function promptCancelledError(): Error {
+  const error = new Error("Prompt cancelled.");
+  (error as Error & { code?: string }).code = "PROMPT_CANCELLED";
+  return error;
+}
+
+/** Whether an unknown error originates from a cancelled prompt. */
+export function isPromptCancelled(error: unknown): boolean {
+  return error instanceof Error && (error as { code?: string }).code === "PROMPT_CANCELLED";
+}
+
+function clampIndex(index: number, length: number): number {
+  if (length === 0) {
+    return 0;
+  }
+  if (index < 0) {
+    return 0;
+  }
+  if (index > length - 1) {
+    return length - 1;
+  }
+  return index;
+}
+
+/** Free-form line input; an empty answer falls back to `defaultValue`. */
+export function text(options: TextOptions): Promise<string> {
+  const input = (options.input ?? process.stdin) as PromptReadable;
+  const output = options.output ?? process.stdout;
+  const prompt = `${options.message} (${options.defaultValue}): `;
+
+  return new Promise<string>((resolve, reject) => {
+    const rl = createInterface({ input, output });
+
+    rl.question(prompt, (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+      resolve(trimmed === "" ? options.defaultValue : trimmed);
+    });
+
+    rl.on("SIGINT", () => {
+      rl.close();
+      reject(promptCancelledError());
+    });
+  });
+}
+
+const CURSOR_POINTER = ">";
+const CLEAR_LINE = "";
+const HIDE_CURSOR = "[?25l";
+const SHOW_CURSOR = "[?25h";
+
+function supportsColor(output: PromptWritable): boolean {
+  return (output as { isTTY?: boolean }).isTTY === true && process.env.NO_COLOR === undefined;
+}
+
+/** Single-choice selection navigated with the arrow keys. */
+export function select<T>(options: SelectOptions<T>): Promise<T> {
+  const input = (options.input ?? process.stdin) as PromptReadable;
+  const output = options.output ?? process.stdout;
+  const choices = options.choices;
+  const color = supportsColor(output);
+  const cyan = (value: string): string => (color ? `${value}` : value);
+  const dim = (value: string): string => (color ? `${value}` : value);
+  let index = clampIndex(options.initialIndex ?? 0, choices.length);
+
+  return new Promise<T>((resolve, reject) => {
+    emitKeypressEvents(input);
+    const isRawCapable = input.isTTY === true;
+    if (isRawCapable) {
+      input.setRawMode?.(true);
+    }
+    input.resume?.();
+
+    const renderChoiceLines = (): string =>
+      choices
+        .map((choice, choiceIndex) => {
+          const active = choiceIndex === index;
+          const prefix = active ? `${CURSOR_POINTER} ` : "  ";
+          const label = active ? cyan(choice.label) : choice.label;
+          const hint = choice.hint === undefined ? "" : ` ${dim(`(${choice.hint})`)}`;
+          return `${CLEAR_LINE}${prefix}${label}${hint}`;
+        })
+        .join("\n");
+
+    let rendered = false;
+    const render = (): void => {
+      if (rendered) {
+        // Move the cursor back to the first choice line before redrawing.
+        output.write(`[${choices.length}A`);
+      }
+      output.write(`${renderChoiceLines()}\n`);
+      rendered = true;
+    };
+
+    const cleanup = (): void => {
+      input.removeListener("keypress", onKeypress);
+      if (isRawCapable) {
+        input.setRawMode?.(false);
+      }
+      if (color) {
+        output.write(SHOW_CURSOR);
+      }
+      input.pause?.();
+    };
+
+    function onKeypress(_value: string | undefined, key: Key | undefined): void {
+      if (key === undefined) {
+        return;
+      }
+
+      if (key.ctrl === true && key.name === "c") {
+        cleanup();
+        reject(promptCancelledError());
+        return;
+      }
+
+      if (key.name === "up") {
+        index = (index - 1 + choices.length) % choices.length;
+        render();
+        return;
+      }
+
+      if (key.name === "down") {
+        index = (index + 1) % choices.length;
+        render();
+        return;
+      }
+
+      if (key.name === "return" || key.name === "enter") {
+        cleanup();
+        const choice = choices[index];
+        if (choice === undefined) {
+          reject(new Error("No choice available to select."));
+          return;
+        }
+        resolve(choice.value);
+      }
+    }
+
+    input.on("keypress", onKeypress);
+    output.write(`${options.message}\n`);
+    if (color) {
+      output.write(HIDE_CURSOR);
+    }
+    render();
+  });
+}

package/src/resolve-create-options.ts

@@ -0,0 +1,129 @@
+import type { CreateMreactAppCreateCliOptions } from "./cli-args.js";
+import type {
+  CreateMreactAppDeployTarget,
+  CreateMreactAppPackageManager,
+  CreateMreactAppTemplate,
+} from "./index.js";
+import { createMreactAppDeployTargets, createMreactAppTemplates } from "./index.js";
+import { select, text } from "./prompts.js";
+
+interface PromptStreamControls {
+  isTTY?: boolean;
+  pause?: () => void;
+  resume?: () => void;
+  setRawMode?: (mode: boolean) => void;
+}
+
+type PromptReadable = NodeJS.ReadableStream & PromptStreamControls;
+type PromptWritable = NodeJS.WritableStream;
+
+export interface ResolveCreateOptionsContext {
+  env?: NodeJS.ProcessEnv | undefined;
+  input?: PromptReadable | undefined;
+  isTTY?: boolean | undefined;
+  output?: PromptWritable | undefined;
+}
+
+export interface ResolvedCreateOptions {
+  deploy?: CreateMreactAppDeployTarget | undefined;
+  directory: string;
+  packageManager: CreateMreactAppPackageManager;
+  srcDir: boolean;
+  template: CreateMreactAppTemplate;
+}
+
+const DEFAULT_DIRECTORY = "mreact-app";
+const DEFAULT_TEMPLATE: CreateMreactAppTemplate = "basic";
+const DEFAULT_PACKAGE_MANAGER: CreateMreactAppPackageManager = "pnpm";
+
+const PACKAGE_MANAGERS: readonly CreateMreactAppPackageManager[] = ["pnpm", "npm", "bun"];
+
+/** Identify the package manager that invoked us via `npm_config_user_agent`. */
+export function detectPackageManager(
+  env: NodeJS.ProcessEnv,
+): CreateMreactAppPackageManager | undefined {
+  const userAgent = env.npm_config_user_agent;
+  if (userAgent === undefined) {
+    return undefined;
+  }
+
+  const name = userAgent.split("/")[0];
+  if (name === "pnpm" || name === "npm" || name === "bun") {
+    return name;
+  }
+
+  return undefined;
+}
+
+/**
+ * Resolve a complete set of scaffolding options from parsed CLI flags.
+ *
+ * Non-interactive (non-TTY): every unprovided option falls back to its
+ * default. Interactive (TTY): only the unprovided options are prompted for.
+ */
+export async function resolveCreateOptions(
+  parsed: CreateMreactAppCreateCliOptions,
+  context: ResolveCreateOptionsContext,
+): Promise<ResolvedCreateOptions> {
+  const env = context.env ?? process.env;
+  const detectedPackageManager = detectPackageManager(env);
+  const packageManagerDefault = detectedPackageManager ?? DEFAULT_PACKAGE_MANAGER;
+
+  if (context.isTTY !== true) {
+    return {
+      deploy: parsed.deploy,
+      directory: parsed.directory ?? DEFAULT_DIRECTORY,
+      packageManager: parsed.packageManager ?? packageManagerDefault,
+      srcDir: parsed.srcDir ?? false,
+      template: parsed.template ?? DEFAULT_TEMPLATE,
+    };
+  }
+
+  const streams = { input: context.input, output: context.output };
+
+  const directory =
+    parsed.directory ??
+    (await text({ defaultValue: DEFAULT_DIRECTORY, message: "Project directory", ...streams }));
+
+  const template =
+    parsed.template ??
+    (await select<CreateMreactAppTemplate>({
+      choices: createMreactAppTemplates.map((value) => ({ label: value, value })),
+      initialIndex: createMreactAppTemplates.indexOf(DEFAULT_TEMPLATE),
+      message: "Template",
+      ...streams,
+    }));
+
+  const packageManager =
+    parsed.packageManager ??
+    (await select<CreateMreactAppPackageManager>({
+      choices: PACKAGE_MANAGERS.map((value) => ({ label: value, value })),
+      initialIndex: PACKAGE_MANAGERS.indexOf(packageManagerDefault),
+      message: "Package manager",
+      ...streams,
+    }));
+
+  const srcDir =
+    parsed.srcDir ??
+    (await select<boolean>({
+      choices: [
+        { label: "No", value: false },
+        { label: "Yes", value: true },
+      ],
+      message: "Place routes under src/app?",
+      ...streams,
+    }));
+
+  const deploy =
+    parsed.deploy ??
+    (await select<CreateMreactAppDeployTarget | undefined>({
+      choices: [
+        { label: "none", value: undefined },
+        ...createMreactAppDeployTargets.map((value) => ({ label: value, value })),
+      ],
+      message: "Deploy target",
+      ...streams,
+    }));
+
+  return { deploy, directory, packageManager, srcDir, template };
+}

package/src/run-cli.ts

@@ -0,0 +1,111 @@
+import { resolve } from "node:path";
+import {
+  createMreactAppHelpText,
+  createMreactAppSuccessText,
+  parseCreateMreactAppCliArgs,
+} from "./cli-args.js";
+import { createMreactApp, upgradeMreactApp } from "./index.js";
+import { isPromptCancelled } from "./prompts.js";
+import { resolveCreateOptions } from "./resolve-create-options.js";
+
+interface PromptStreamControls {
+  isTTY?: boolean;
+  pause?: () => void;
+  resume?: () => void;
+  setRawMode?: (mode: boolean) => void;
+}
+
+export interface RunCliContext {
+  /** Environment used for package-manager detection. Defaults to `process.env`. */
+  env?: NodeJS.ProcessEnv | undefined;
+  /** Stream the interactive prompts read from. Defaults to `process.stdin`. */
+  input?: (NodeJS.ReadableStream & PromptStreamControls) | undefined;
+  /** Whether to run the interactive wizard for unprovided options. */
+  isTTY?: boolean | undefined;
+  /** Stream the interactive prompts render to. Defaults to `process.stdout`. */
+  output?: NodeJS.WritableStream | undefined;
+  /** Sink for error messages. Defaults to `console.error`. */
+  stderr?: ((line: string) => void) | undefined;
+  /** Sink for normal output. Defaults to `console.log`. */
+  stdout?: ((line: string) => void) | undefined;
+}
+
+const EXIT_OK = 0;
+const EXIT_ERROR = 1;
+const EXIT_CANCELLED = 130;
+
+/**
+ * Run the create-mreact-app CLI and return a process exit code.
+ *
+ * Pulled out of the bin shim so the full flow (parse -> resolve -> scaffold)
+ * is testable with in-memory streams and without touching `process`.
+ */
+export async function runCreateMreactAppCli(
+  argv: readonly string[],
+  context: RunCliContext = {},
+): Promise<number> {
+  const stdout = context.stdout ?? ((line: string) => console.log(line));
+  const stderr = context.stderr ?? ((line: string) => console.error(line));
+
+  try {
+    const options = parseCreateMreactAppCliArgs(argv);
+
+    if (options.help === true) {
+      stdout(createMreactAppHelpText());
+      return EXIT_OK;
+    }
+
+    if (options.command === "upgrade") {
+      const result = await upgradeMreactApp({
+        directory: resolve(options.directory ?? "."),
+        dryRun: options.dryRun,
+        fromVersion: options.fromVersion,
+        targetVersion: options.targetVersion,
+      });
+
+      stdout(
+        result.changed
+          ? `Updated ${result.updatedDependencies.length} mreact dependency range(s).`
+          : "No mreact dependency ranges needed updating.",
+      );
+      if (result.codemods.length > 0) {
+        stdout(`Codemods: ${result.codemods.map((codemod) => codemod.id).join(", ")}`);
+      }
+      return EXIT_OK;
+    }
+
+    const resolved = await resolveCreateOptions(options, {
+      env: context.env ?? process.env,
+      input: context.input,
+      isTTY: context.isTTY,
+      output: context.output,
+    });
+
+    const result = await createMreactApp({
+      deploy: resolved.deploy,
+      directory: resolve(resolved.directory),
+      // Leave `name` unset so createMreactApp derives a workspace-aware package
+      // name from the target directory (e.g. @reckona/example-<name> under examples/*).
+      packageManager: resolved.packageManager,
+      srcDir: resolved.srcDir,
+      template: resolved.template,
+    });
+
+    stdout(
+      createMreactAppSuccessText({
+        directory: result.directory,
+        displayDirectory: resolved.directory,
+        packageManager: result.packageManager,
+        template: result.template,
+      }),
+    );
+    return EXIT_OK;
+  } catch (error) {
+    if (isPromptCancelled(error)) {
+      stderr("Aborted.");
+      return EXIT_CANCELLED;
+    }
+    stderr(error instanceof Error ? error.message : String(error));
+    return EXIT_ERROR;
+  }
+}