create-react-on-rails-app 16.5.1 → 16.6.0-rc.1

package/lib/create-app.js

@@ -10,6 +10,94 @@ const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const utils_js_1 = require("./utils.js");
 const DOCS_URL = 'https://reactonrails.com/docs/';
+const DEFAULT_GIT_AUTHOR_NAME = 'React on Rails Generator';
+const DEFAULT_GIT_AUTHOR_EMAIL = 'generator@reactonrails.invalid';
+const SUPPORTED_RAILTIES_MAJORS = [7, 8];
+// Keep this renderer intentionally minimal. It renders Rails' installed
+// gitignore/gitattributes templates and falls back to bundled defaults when:
+// - railties is unavailable in the current Ruby environment, or
+// - railties major version is outside SUPPORTED_RAILTIES_MAJORS.
+const RAILS_GIT_TEMPLATE_RENDERER = `
+require "erb"
+
+class ReactOnRailsGitTemplateOptions
+  def api? = false
+
+  def [](key)
+    key == :skip_active_record ? false : nil
+  end
+end
+
+class ReactOnRailsGitTemplateContext
+  def keeps? = true
+
+  def skip_storage? = false
+
+  def options = ReactOnRailsGitTemplateOptions.new
+
+  def get_binding
+    binding
+  end
+end
+
+spec = Gem::Specification.find_by_name("railties")
+railties_major = spec.version.segments.first
+unless [${SUPPORTED_RAILTIES_MAJORS.join(', ')}].include?(railties_major)
+  warn "Unsupported railties major version for git template rendering: #{spec.version}"
+  exit 1
+end
+template_path = File.join(spec.gem_dir, "lib/rails/generators/rails/app/templates", ARGV[0])
+template = File.read(template_path)
+print ERB.new(template, trim_mode: "-").result(ReactOnRailsGitTemplateContext.new.get_binding)
+`;
+// Fallback copy of the Rails git scaffold (validated against Rails 7.2 templates)
+// for environments where rendering the installed railties templates is unavailable.
+const RAILS_GITIGNORE_FALLBACK = `# See https://help.github.com/articles/ignoring-files for more about ignoring files.
+#
+# Temporary files generated by your text editor or operating system
+# belong in git's global ignore instead:
+# \`$XDG_CONFIG_HOME/git/ignore\` or \`~/.config/git/ignore\`
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore all environment files.
+/.env*
+
+# Ignore all logfiles and tempfiles.
+/log/*
+/tmp/*
+!/log/.keep
+!/tmp/.keep
+
+# Ignore node modules.
+/node_modules
+
+# Ignore pidfiles, but keep the directory.
+/tmp/pids/*
+!/tmp/pids/
+!/tmp/pids/.keep
+
+# Ignore storage (uploaded files in development and any SQLite databases).
+/storage/*
+!/storage/.keep
+/tmp/storage/*
+!/tmp/storage/
+!/tmp/storage/.keep
+
+/public/assets
+
+# Ignore key files for decrypting credentials and more.
+/config/*.key
+`;
+const RAILS_GITATTRIBUTES_FALLBACK = `# See https://git-scm.com/docs/gitattributes for more about git attribute files.
+
+# Mark the database schema as having been generated.
+db/schema.rb linguist-generated
+
+# Mark any vendored files as having been vendored.
+vendor/* linguist-vendored
+`;
 function cleanupAppDirectory(appPath, appName, cleanupSuccessMessage, cleanupFallbackMessage) {
     if (!fs_1.default.existsSync(appPath)) {
         return;
@@ -46,7 +134,7 @@ function bundleAddArgs(gemName, localPath, strict = true) {
     return args;
 }
 function buildGeneratorArgs(options) {
-    const args = [];
+    const args = ['--new-app'];
     if (options.template === 'typescript') {
         args.push('--typescript');
     }
@@ -63,10 +151,9 @@ function buildGeneratorArgs(options) {
     // --force makes the generator overwrite conflicting files without prompting,
     // which is safe for a freshly scaffolded app with no custom content yet.
     args.push('--force');
-    // The newly created app directory is not a git repo yet, so the generator's
-    // uncommitted-changes check would always warn. --ignore-warnings bypasses all
-    // generator validation warnings (git, Node version, package manager) which is
-    // acceptable for a fresh app where prerequisites were already checked above.
+    // Keep the create-app flow non-interactive. --ignore-warnings bypasses generator
+    // validation warnings (git, Node version, package manager) because the CLI
+    // already checked prerequisites and is driving a fresh-app automation path.
     args.push('--ignore-warnings');
     return args;
 }
@@ -102,6 +189,30 @@ function rewriteFileIfPresent(filePath, transform) {
         fs_1.default.writeFileSync(filePath, updated, 'utf8');
     }
 }
+function readInstalledRailsGitTemplate(appPath, templateName) {
+    try {
+        const renderedTemplate = (0, utils_js_1.execCaptureArgs)('ruby', ['-e', RAILS_GIT_TEMPLATE_RENDERER, templateName], appPath);
+        return renderedTemplate.length > 0 ? `${renderedTemplate}\n` : null;
+    }
+    catch {
+        return null;
+    }
+}
+function railsGitScaffold(appPath) {
+    const renderedGitignore = readInstalledRailsGitTemplate(appPath, 'gitignore.tt');
+    const renderedGitattributes = readInstalledRailsGitTemplate(appPath, 'gitattributes.tt');
+    return {
+        gitignore: renderedGitignore ?? RAILS_GITIGNORE_FALLBACK,
+        gitattributes: renderedGitattributes ?? RAILS_GITATTRIBUTES_FALLBACK,
+    };
+}
+function restoreRailsGitScaffold(appPath) {
+    // Rails omits .gitignore/.gitattributes when rails new runs with --skip-git.
+    // Recreate the defaults so the educational commit history stays clean.
+    const scaffold = railsGitScaffold(appPath);
+    fs_1.default.writeFileSync(path_1.default.join(appPath, '.gitignore'), scaffold.gitignore, 'utf8');
+    fs_1.default.writeFileSync(path_1.default.join(appPath, '.gitattributes'), scaffold.gitattributes, 'utf8');
+}
 function normalizeGeneratedPackageManager(appPath, packageManager) {
     if (packageManager !== 'pnpm') {
         return;
@@ -133,7 +244,95 @@ function normalizeGeneratedPackageManager(appPath, packageManager) {
     });
     (0, utils_js_1.logStepDone)('pnpm configuration applied');
 }
-function printSuccessMessage(appName, route) {
+function ensureGitRepository(appPath) {
+    if (fs_1.default.existsSync(path_1.default.join(appPath, '.git'))) {
+        return;
+    }
+    (0, utils_js_1.execLiveArgs)('git', ['init'], appPath);
+}
+function readGitConfig(appPath, key) {
+    try {
+        const value = (0, utils_js_1.execCaptureArgs)('git', ['config', '--get', key], appPath);
+        return value === '' ? null : value;
+    }
+    catch {
+        return null;
+    }
+}
+function educationalGitEnv(appPath) {
+    const userName = readGitConfig(appPath, 'user.name') ?? DEFAULT_GIT_AUTHOR_NAME;
+    const userEmail = readGitConfig(appPath, 'user.email') ?? DEFAULT_GIT_AUTHOR_EMAIL;
+    return {
+        ...process.env,
+        GIT_AUTHOR_NAME: userName,
+        GIT_AUTHOR_EMAIL: userEmail,
+        GIT_COMMITTER_NAME: userName,
+        GIT_COMMITTER_EMAIL: userEmail,
+    };
+}
+function gitHasPendingChanges(appPath) {
+    try {
+        return (0, utils_js_1.execCaptureArgs)('git', ['status', '--porcelain'], appPath) !== '';
+    }
+    catch {
+        return false;
+    }
+}
+function createEducationalCommit(appPath, subject, body, educationalGitEnvForCommit) {
+    ensureGitRepository(appPath);
+    if (!gitHasPendingChanges(appPath)) {
+        return false;
+    }
+    // The educational history intentionally snapshots each full scaffold step.
+    (0, utils_js_1.execLiveArgs)('git', ['add', '-A'], appPath);
+    (0, utils_js_1.execLiveArgs)('git', ['-c', 'commit.gpgsign=false', 'commit', '-m', subject, '-m', body], appPath, educationalGitEnvForCommit());
+    return true;
+}
+function railsBaselineCommitMessage() {
+    return {
+        subject: 'Create Rails app with PostgreSQL',
+        body: 'Generate the fresh Rails baseline before adding React on Rails.',
+    };
+}
+function reactOnRailsGemCommitMessage() {
+    return {
+        subject: 'Add react_on_rails gem',
+        body: 'Install the OSS gem so the next commit can run the React on Rails generator.',
+    };
+}
+function reactOnRailsProCommitMessage(modeFlag) {
+    return {
+        subject: 'Add react_on_rails_pro gem',
+        body: `Install the Pro gem required by ${modeFlag} before running the generator.`,
+    };
+}
+function generatorCommitMessage(options) {
+    const language = options.template === 'typescript' ? 'TypeScript' : 'JavaScript';
+    const bundler = options.rspack ? 'Rspack' : 'Webpack';
+    if (options.rsc) {
+        return {
+            subject: `Install React Server Components with ${language} and ${bundler}`,
+            body: 'Run react_on_rails:install --rsc to add the generated home page, HelloServer example, and Pro RSC wiring.',
+        };
+    }
+    if (options.pro) {
+        return {
+            subject: `Install React on Rails Pro with ${language} and ${bundler}`,
+            body: 'Run react_on_rails:install --pro to add the generated home page, SSR example, and Pro Node renderer wiring.',
+        };
+    }
+    return {
+        subject: `Install React on Rails with ${language} and ${bundler}`,
+        body: 'Run react_on_rails:install to add the generated home page, SSR example, and development workflow.',
+    };
+}
+function pnpmCommitMessage() {
+    return {
+        subject: 'Normalize the generated app for pnpm',
+        body: 'Convert npm artifacts to pnpm, remove package-lock.json, and update bin/setup to use pnpm install.',
+    };
+}
+function printSuccessMessage(appName, educationalCommitsEnabled) {
     console.log('');
     (0, utils_js_1.logSuccess)(`Created ${appName} with React on Rails!`);
     console.log('');
@@ -144,7 +343,16 @@ function printSuccessMessage(appName, route) {
     console.log('');
     (0, utils_js_1.logInfo)('Note: The generated app uses PostgreSQL by default. Start PostgreSQL before running bin/rails db:prepare.');
     console.log('');
-    (0, utils_js_1.logInfo)(`Then visit http://localhost:3000/${route}`);
+    (0, utils_js_1.logInfo)('Then visit http://localhost:3000');
+    (0, utils_js_1.logInfo)('bin/dev will try to open the generated home page on first successful boot.');
+    console.log('');
+    if (educationalCommitsEnabled) {
+        (0, utils_js_1.logInfo)('Educational commits skip GPG signing so scaffold automation does not block on local signer prompts.');
+        (0, utils_js_1.logInfo)('Educational git history: git log --oneline --reverse');
+    }
+    else {
+        (0, utils_js_1.logInfo)('Educational git history is partial because git commit automation was skipped after an earlier failure.');
+    }
     console.log('');
     (0, utils_js_1.logInfo)(`Documentation: ${DOCS_URL}`);
     console.log('');
@@ -175,24 +383,49 @@ function validateAppName(name) {
 function createApp(appName, options) {
     const appPath = path_1.default.resolve(process.cwd(), appName);
     const proRequested = options.pro || options.rsc;
+    let educationalCommitsEnabled = true;
+    let cachedEducationalGitEnv = null;
     let proModeLabel = null;
-    if (options.rsc) {
-        proModeLabel = '--rsc';
-    }
-    else if (options.pro) {
-        proModeLabel = '--pro';
+    if (proRequested) {
+        proModeLabel = options.rsc ? '--rsc' : '--pro';
     }
     const baseSteps = 3; // rails new + add react_on_rails + run generator
     const totalSteps = baseSteps + (proRequested ? 1 : 0);
     let currentStep = 1;
     const reactOnRailsGemPath = localGemPath('REACT_ON_RAILS_GEM_PATH');
     const reactOnRailsProGemPath = proRequested ? localGemPath('REACT_ON_RAILS_PRO_GEM_PATH') : null;
+    function educationalGitEnvForCommits() {
+        if (!cachedEducationalGitEnv) {
+            // The baseline commit happens before git init; in that case git config falls back
+            // to the user's global identity, which is the behavior we want here.
+            cachedEducationalGitEnv = educationalGitEnv(appPath);
+        }
+        return cachedEducationalGitEnv;
+    }
+    function recordEducationalCommit(subject, body) {
+        if (!educationalCommitsEnabled) {
+            return;
+        }
+        try {
+            createEducationalCommit(appPath, subject, body, educationalGitEnvForCommits);
+        }
+        catch (error) {
+            educationalCommitsEnabled = false;
+            (0, utils_js_1.logInfo)(`Educational git history paused after "${subject}" because git commit automation failed. The app scaffold will continue.`);
+            if (error instanceof Error && error.message) {
+                console.error(`Git debug info: ${error.message}`);
+            }
+        }
+    }
     // Step 1: Create Rails application
     // appName is validated by validateAppName() to be ^[a-zA-Z][a-zA-Z0-9]*([_-][a-zA-Z0-9]+)*$ only,
     // so it's always a simple directory name safe to use with rails new.
     (0, utils_js_1.logStep)(currentStep, totalSteps, 'Creating Rails application...');
     try {
-        (0, utils_js_1.execLiveArgs)('rails', ['new', appName, '--database=postgresql', '--skip-javascript']);
+        (0, utils_js_1.execLiveArgs)('rails', ['new', appName, '--database=postgresql', '--skip-javascript', '--skip-git']);
+        restoreRailsGitScaffold(appPath);
+        const { subject, body } = railsBaselineCommitMessage();
+        recordEducationalCommit(subject, body);
         (0, utils_js_1.logStepDone)('Rails application created');
     }
     catch (error) {
@@ -212,6 +445,8 @@ function createApp(appName, options) {
             (0, utils_js_1.logInfo)(`Using local react_on_rails gem path: ${reactOnRailsGemPath}`);
         }
         (0, utils_js_1.execLiveArgs)('bundle', reactOnRailsArgs, appPath);
+        const { subject, body } = reactOnRailsGemCommitMessage();
+        recordEducationalCommit(subject, body);
         (0, utils_js_1.logStepDone)('react_on_rails gem added');
     }
     catch (error) {
@@ -231,6 +466,8 @@ function createApp(appName, options) {
                 (0, utils_js_1.logInfo)(`Using local react_on_rails_pro gem path: ${reactOnRailsProGemPath}`);
             }
             (0, utils_js_1.execLiveArgs)('bundle', reactOnRailsProArgs, appPath);
+            const { subject, body } = reactOnRailsProCommitMessage(proModeLabel ?? '--pro');
+            recordEducationalCommit(subject, body);
             (0, utils_js_1.logStepDone)('react_on_rails_pro gem added');
         }
         catch (error) {
@@ -251,6 +488,8 @@ function createApp(appName, options) {
             ...process.env,
             REACT_ON_RAILS_PACKAGE_MANAGER: options.packageManager,
         });
+        const { subject, body } = generatorCommitMessage(options);
+        recordEducationalCommit(subject, body);
         (0, utils_js_1.logStepDone)('React on Rails setup complete');
     }
     catch (error) {
@@ -263,6 +502,10 @@ function createApp(appName, options) {
     }
     try {
         normalizeGeneratedPackageManager(appPath, options.packageManager);
+        if (options.packageManager === 'pnpm') {
+            const { subject, body } = pnpmCommitMessage();
+            recordEducationalCommit(subject, body);
+        }
     }
     catch (error) {
         (0, utils_js_1.logError)(`Failed to finish ${options.packageManager} setup. The app was created, but package manager normalization did not complete.`);
@@ -280,6 +523,6 @@ function createApp(appName, options) {
     }
     // Final success
     (0, utils_js_1.logStepDone)('Done!');
-    printSuccessMessage(appName, options.rsc ? 'hello_server' : 'hello_world');
+    printSuccessMessage(appName, educationalCommitsEnabled);
 }
 //# sourceMappingURL=create-app.js.map

package/lib/index.d.ts

@@ -1,2 +1,3 @@
-export {};
+import { Command } from 'commander';
+export declare const ready: Promise<Command>;
 //# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -3,15 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ready = void 0;
 const commander_1 = require("commander");
 const chalk_1 = __importDefault(require("chalk"));
 const validators_js_1 = require("./validators.js");
 const create_app_js_1 = require("./create-app.js");
 const utils_js_1 = require("./utils.js");
+const prompt_js_1 = require("./prompt.js");
 // Use require() for CJS compatibility - avoids __dirname + fs.readFileSync
 // eslint-disable-next-line @typescript-eslint/no-require-imports, global-require
 const packageJson = require('../package.json');
-function run(appName, rawOpts) {
+async function run(appName, rawOpts) {
     const { template } = rawOpts;
     if (typeof template !== 'string' || (template !== 'javascript' && template !== 'typescript')) {
         (0, utils_js_1.logError)(`Invalid template "${String(template)}". Must be "javascript" or "typescript".`);
@@ -27,13 +29,8 @@ function run(appName, rawOpts) {
     else {
         packageManager = (0, utils_js_1.detectPackageManager)() ?? 'npm';
     }
-    const options = {
-        template,
-        packageManager: packageManager,
-        rspack: Boolean(rawOpts.rspack),
-        pro: Boolean(rawOpts.pro),
-        rsc: Boolean(rawOpts.rsc),
-    };
+    let pro = Boolean(rawOpts.pro);
+    let rsc = Boolean(rawOpts.rsc);
     console.log('');
     console.log(`${chalk_1.default.bold('create-react-on-rails-app')} v${packageJson.version}`);
     console.log('');
@@ -42,6 +39,26 @@ function run(appName, rawOpts) {
         (0, utils_js_1.logError)(nameValidation.error ?? 'Invalid app name');
         process.exit(1);
     }
+    // When no mode flag is explicitly passed, prompt interactively (TTY only).
+    // Non-interactive environments (CI, pipes) fall back to standard mode.
+    const modeExplicit = rawOpts.pro !== undefined || rawOpts.rsc !== undefined || rawOpts.standard !== undefined;
+    if (!modeExplicit) {
+        if (process.stdin.isTTY && process.stdout.isTTY) {
+            const choice = await (0, prompt_js_1.promptForMode)();
+            pro = choice.pro;
+            rsc = choice.rsc;
+        }
+        else {
+            (0, utils_js_1.logInfo)('No mode flag specified and not running interactively (stdin/stdout is not a TTY); using standard mode.');
+        }
+    }
+    const options = {
+        template,
+        packageManager: packageManager,
+        rspack: Boolean(rawOpts.rspack),
+        pro,
+        rsc,
+    };
     if (options.rsc && options.pro) {
         (0, utils_js_1.logInfo)('Note: --rsc takes precedence over --pro; --pro will be ignored.');
     }
@@ -93,39 +110,60 @@ program
     .option('-t, --template <type>', 'javascript or typescript', 'typescript')
     .option('-p, --package-manager <pm>', 'npm or pnpm (auto-detected if not specified)')
     .option('--rspack', 'Use Rspack instead of Webpack (~20x faster builds)', false)
-    .option('--pro', 'Generate React on Rails Pro setup (installs react_on_rails_pro)', false)
-    .option('--rsc', 'Generate React Server Components setup (installs react_on_rails_pro)', false)
+    .option('--standard', 'Generate open-source React on Rails setup (skip prompt)')
+    .option('--pro', 'Generate React on Rails Pro setup (installs react_on_rails_pro)')
+    .option('--rsc', 'Generate React Server Components setup (installs react_on_rails_pro)')
     .addHelpText('after', `
 Examples:
-  $ npx create-react-on-rails-app my-app
+  $ npx create-react-on-rails-app my-app                        # prompts for mode
+  $ npx create-react-on-rails-app my-app --rsc                  # skip prompt, use RSC
+  $ npx create-react-on-rails-app my-app --pro                  # skip prompt, use Pro
+  $ npx create-react-on-rails-app my-app --standard             # skip prompt, use Standard
   $ npx create-react-on-rails-app my-app --template javascript
   $ npx create-react-on-rails-app my-app --rspack
-  $ npx create-react-on-rails-app my-app --pro
-  $ npx create-react-on-rails-app my-app --rsc
-  $ npx create-react-on-rails-app my-app --rspack --pro
   $ npx create-react-on-rails-app my-app --rspack --rsc
   $ npx create-react-on-rails-app my-app --package-manager pnpm
 
+When no mode flag (--standard, --pro, or --rsc) is given, an interactive prompt
+lets you choose between Standard, Pro, and RSC modes (default: RSC). When stdin
+or stdout is not a TTY (for example in CI, piped input, or redirected output),
+standard mode is used automatically.
+
 What it does:
   1. Creates a new Rails app with PostgreSQL
-  2. Adds required gem(s) (react_on_rails, plus react_on_rails_pro for --pro/--rsc)
+  2. Adds required gem(s) (react_on_rails, plus react_on_rails_pro for Pro/RSC)
   3. Runs the React on Rails generator (Shakapacker, components, webpack config)
+  4. Creates educational git commits for each major scaffold step
 
 After setup, run bin/dev and visit:
-  - http://localhost:3000/hello_world (default and --pro)
-  - http://localhost:3000/hello_server (--rsc)
+  - http://localhost:3000 (generated home page)
+  - /hello_world (default and --pro example page)
+  - /hello_server (--rsc example page)
 
+Inspect the generated setup history with:
+  - git log --oneline --reverse
+
+The generated app includes one git commit per logical setup step.`)
+    .addHelpText('after', `
 --pro and --rsc support both JavaScript and TypeScript templates.
 
 Documentation: https://reactonrails.com/docs/`)
-    .action((appName, opts) => {
+    .action(async (appName, opts) => {
     try {
-        run(appName, opts);
+        await run(appName, opts);
     }
     catch (error) {
+        if (error instanceof Error && error.message === prompt_js_1.PROMPT_CANCELLED) {
+            console.log('');
+            process.exit(0);
+        }
         (0, utils_js_1.logError)(error instanceof Error ? error.message : String(error));
         process.exit(1);
     }
 });
-program.parse();
+// eslint-disable-next-line import/prefer-default-export -- named export for test clarity
+exports.ready = program.parseAsync().catch((error) => {
+    (0, utils_js_1.logError)(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});
 //# sourceMappingURL=index.js.map

package/lib/prompt.d.ts

@@ -0,0 +1,7 @@
+export interface ModeChoice {
+    pro: boolean;
+    rsc: boolean;
+}
+export declare const PROMPT_CANCELLED = "Prompt cancelled by user";
+export declare function promptForMode(): Promise<ModeChoice>;
+//# sourceMappingURL=prompt.d.ts.map

package/lib/prompt.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROMPT_CANCELLED = void 0;
+exports.promptForMode = promptForMode;
+const readline_1 = __importDefault(require("readline"));
+const chalk_1 = __importDefault(require("chalk"));
+exports.PROMPT_CANCELLED = 'Prompt cancelled by user';
+const MODES = [
+    {
+        key: '1',
+        label: 'Standard',
+        desc: 'Open-source React on Rails with SSR',
+        pro: false,
+        rsc: false,
+    },
+    {
+        key: '2',
+        label: 'Pro',
+        desc: 'Adds Node.js server rendering (requires react_on_rails_pro)',
+        pro: true,
+        rsc: false,
+    },
+    {
+        key: '3',
+        label: 'RSC',
+        desc: 'React Server Components (requires react_on_rails_pro)',
+        pro: false,
+        rsc: true,
+    },
+];
+const DEFAULT_KEY = '3';
+function promptForMode() {
+    return new Promise((resolve, reject) => {
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        let answered = false;
+        rl.on('SIGINT', () => {
+            answered = true;
+            rl.close();
+            reject(new Error(exports.PROMPT_CANCELLED));
+        });
+        rl.once('close', () => {
+            if (!answered) {
+                reject(new Error(exports.PROMPT_CANCELLED));
+            }
+        });
+        console.log(chalk_1.default.bold('Select a setup mode:\n'));
+        for (const mode of MODES) {
+            const recommended = mode.key === DEFAULT_KEY ? chalk_1.default.cyan(' (recommended)') : '';
+            console.log(`  ${mode.key}. ${chalk_1.default.bold(mode.label.padEnd(10))} ${mode.desc}${recommended}`);
+        }
+        console.log('');
+        rl.question(`Choice (1-3) [${DEFAULT_KEY}]: `, (answer) => {
+            answered = true;
+            rl.close();
+            const key = answer.trim() || DEFAULT_KEY;
+            const selected = MODES.find((m) => m.key === key);
+            if (!selected) {
+                console.log(chalk_1.default.yellow(`Invalid choice "${key}", defaulting to RSC.`));
+                resolve({ pro: false, rsc: true });
+                return;
+            }
+            resolve({ pro: selected.pro, rsc: selected.rsc });
+        });
+    });
+}
+//# sourceMappingURL=prompt.js.map

package/lib/utils.d.ts

@@ -6,6 +6,7 @@
  * - Callers must still ensure `command` and `args` come from trusted/validated values.
  */
 export declare function execLiveArgs(command: string, args: string[], cwd?: string, env?: NodeJS.ProcessEnv): void;
+export declare function execCaptureArgs(command: string, args: string[], cwd?: string, env?: NodeJS.ProcessEnv): string;
 export declare function getCommandVersion(command: string): string | null;
 export declare function detectPackageManager(): 'npm' | 'pnpm' | null;
 export declare function logStep(current: number, total: number, message: string): void;

package/lib/utils.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.execLiveArgs = execLiveArgs;
+exports.execCaptureArgs = execCaptureArgs;
 exports.getCommandVersion = getCommandVersion;
 exports.detectPackageManager = detectPackageManager;
 exports.logStep = logStep;
@@ -13,6 +14,10 @@ exports.logSuccess = logSuccess;
 exports.logInfo = logInfo;
 const child_process_1 = require("child_process");
 const chalk_1 = __importDefault(require("chalk"));
+function childEnv(env) {
+    // Always inherit PATH, HOME, and the rest of process.env; callers only add/override keys.
+    return env ? { ...process.env, ...env } : process.env;
+}
 /**
  * Execute a command and stream output to the current terminal.
  *
@@ -24,15 +29,39 @@ function execLiveArgs(command, args, cwd, env) {
     const result = (0, child_process_1.spawnSync)(command, args, {
         stdio: 'inherit',
         cwd,
-        ...(env ? { env } : {}),
+        env: childEnv(env),
     });
     if (result.error) {
         throw result.error;
     }
+    if (result.status === null) {
+        throw new Error(`Command "${command}" was terminated by ${result.signal ?? 'unknown signal'}`);
+    }
     if (result.status !== 0) {
         throw new Error(`Command "${command}" exited with code ${result.status}`);
     }
 }
+function execCaptureArgs(command, args, cwd, env) {
+    const result = (0, child_process_1.spawnSync)(command, args, {
+        stdio: 'pipe',
+        encoding: 'utf8',
+        cwd,
+        env: childEnv(env),
+    });
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status === null) {
+        throw new Error(`Command "${command}" was terminated by ${result.signal ?? 'unknown signal'}`);
+    }
+    if (result.status !== 0) {
+        const stderr = result.stderr?.trim();
+        throw new Error(stderr && stderr.length > 0
+            ? `Command "${command}" exited with code ${result.status}: ${stderr}`
+            : `Command "${command}" exited with code ${result.status}`);
+    }
+    return result.stdout?.trim() ?? '';
+}
 function getCommandVersion(command) {
     try {
         return (0, child_process_1.execFileSync)(command, ['--version'], { encoding: 'utf8', stdio: 'pipe' }).trim();

package/lib/validators.d.ts

@@ -2,6 +2,7 @@ import { ValidationResult } from './types.js';
 export declare function validateNode(): ValidationResult;
 export declare function validateRuby(): ValidationResult;
 export declare function validateRails(): ValidationResult;
+export declare function validateGit(): ValidationResult;
 export declare function validatePackageManager(pm: 'npm' | 'pnpm'): ValidationResult;
 export interface PrerequisiteResults {
     allValid: boolean;

package/lib/validators.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateNode = validateNode;
 exports.validateRuby = validateRuby;
 exports.validateRails = validateRails;
+exports.validateGit = validateGit;
 exports.validatePackageManager = validatePackageManager;
 exports.validateAll = validateAll;
 const utils_js_1 = require("./utils.js");
@@ -85,6 +86,19 @@ function validateRails() {
     }
     return { valid: true, message: firstLine };
 }
+function validateGit() {
+    const gitVersion = (0, utils_js_1.getCommandVersion)('git');
+    if (!gitVersion) {
+        return {
+            valid: false,
+            message: 'git is not installed or not found in PATH.\n\n' +
+                'create-react-on-rails-app now records the generated app as a step-by-step git history.\n' +
+                'Install git, then try again:\n' +
+                '  https://git-scm.com/downloads',
+        };
+    }
+    return { valid: true, message: gitVersion.split('\n')[0].trim() };
+}
 function validatePackageManager(pm) {
     const version = (0, utils_js_1.getCommandVersion)(pm);
     if (!version) {
@@ -100,6 +114,7 @@ function validateAll(packageManager) {
         { name: 'Node.js', result: validateNode() },
         { name: 'Ruby', result: validateRuby() },
         { name: 'Rails', result: validateRails() },
+        { name: 'git', result: validateGit() },
         { name: 'Package Manager', result: validatePackageManager(packageManager) },
     ];
     const allValid = results.every((r) => r.result.valid);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-react-on-rails-app",
-  "version": "16.5.1",
+  "version": "16.6.0-rc.1",
   "description": "Create React on Rails applications with a single command",
   "bin": {
     "create-react-on-rails-app": "./bin/create-react-on-rails-app.js"