create-rsc-kit 0.1.0

package/README.md

@@ -0,0 +1,23 @@
+# create-rsc-kit
+
+Scaffold a React Server Components app that builds and runs before you edit it.
+
+```sh
+bun create rsc-kit my-app
+```
+
+Asks which server (Bun, Hono, Elysia or `node:http`), whether you want the React
+Compiler, and whether to include Tailwind. Every answer has a flag, so it runs
+unattended too:
+
+```sh
+bun create rsc-kit my-app --host=hono --compiler=oxc --tailwind
+```
+
+The point is not the typing it saves. Several things in this setup fail by
+producing an app that looks nearly right — a server that serves a development
+payload to a production client, a stylesheet with no server-component classes
+in it, an engine declaration that typechecks the server and fails the prerender.
+What comes out has those right.
+
+Docs: https://rsc-kit.dev · Licence: MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+// create-rsc-kit — scaffold an app that builds and runs before it is edited.
+//
+// The point is not saving typing. It is that the combination of choices has
+// several things in it that are invisible when wrong: NODE_ENV on the build,
+// @source for Tailwind, the ambient declaration for the generated engine
+// bundle. Each of those fails by producing a page that looks nearly right.
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawnSync } from 'node:child_process';
+import { argv, exit, stdout } from 'node:process';
+import { DEFAULT_COMPILER, HELP, HOSTS, PUBLISHED_CORE, assertInsideCwd, assertUsableName, defaultCore, parseArgs, } from './options.js';
+import { Prompter, bold, cyan, dim } from './prompt.js';
+import * as t from './templates.js';
+const flags = parseArgs(argv.slice(2));
+if (flags.help) {
+    stdout.write(HELP);
+    exit(0);
+}
+const unattended = flags.host !== undefined;
+// Resolved once: it walks up from this file looking for the sibling package.
+const core = flags.core ?? defaultCore(dirname(fileURLToPath(import.meta.url)));
+const options = await collect();
+try {
+    write(options);
+}
+catch (error) {
+    // A refusal is a message, not a crash dump. Everything thrown from write()
+    // is a decision this tool made deliberately — an unusable name, a directory
+    // outside where it was run — and a stack trace buries the sentence that
+    // says which.
+    stdout.write(`\n${bold('Cannot scaffold here.')}\n  ${error.message}\n\n`);
+    exit(1);
+}
+if (options.git)
+    run('git', ['init', '--quiet'], options.dir);
+if (options.install) {
+    stdout.write(`\n${dim('Installing dependencies…')}\n`);
+    const pm = options.host === 'node' ? 'npm' : 'bun';
+    const ok = run(pm, ['install'], options.dir);
+    if (!ok) {
+        stdout.write(`\n${bold('Dependencies did not install.')} The files are written; run the install yourself.\n` +
+            (options.core === PUBLISHED_CORE
+                ? dim('  @rsc-kit/core may not be published yet — pass --core=file:<path> to use a local checkout.\n')
+                : ''));
+    }
+}
+report(options);
+// ── ─────────────────────────────────────────────────────────────────────────
+/** Declared, not assigned: collect() runs at module top level, above this. */
+function basename(path) {
+    return path.replace(/\/+$/, '').split('/').pop() || 'app';
+}
+async function collect() {
+    if (unattended) {
+        const dir = flags.dir ?? 'my-app';
+        return {
+            dir: resolve(dir),
+            name: basename(dir),
+            host: flags.host,
+            compiler: flags.compiler ?? 'none',
+            tailwind: flags.tailwind ?? true,
+            lint: flags.lint ?? true,
+            sourceDir: flags.sourceDir ?? 'src',
+            install: flags.install ?? true,
+            git: flags.git ?? true,
+            core,
+        };
+    }
+    // Nothing is attached to answer. readline would simply never resolve, and a
+    // scaffolder that hangs with no output is indistinguishable from a slow one.
+    if (!process.stdin.isTTY) {
+        stdout.write(`\n${bold('No terminal to ask questions on.')}\n` +
+            dim('  Pass the answers as flags instead, e.g.\n') +
+            `  ${cyan('create-rsc-kit my-app --host=bun --compiler=none --no-tailwind')}\n` +
+            HELP);
+        exit(1);
+    }
+    stdout.write(`\n${bold('Create an RSC app')}\n\n`);
+    const p = new Prompter();
+    try {
+        const dir = flags.dir ?? (await p.text('Directory', 'my-app'));
+        const host = await p.select('Server', HOSTS);
+        // Yes/no, not which: see DEFAULT_COMPILER.
+        const compiler = flags.compiler ?? ((await p.confirm('React Compiler', true)) ? DEFAULT_COMPILER : 'none');
+        const tailwind = flags.tailwind ?? (await p.confirm('Tailwind CSS', true));
+        const lint = flags.lint ?? (await p.confirm('oxlint', true));
+        return {
+            dir: resolve(dir),
+            name: basename(dir),
+            host,
+            compiler,
+            tailwind,
+            lint,
+            sourceDir: flags.sourceDir ?? 'src',
+            install: flags.install ?? (await p.confirm('Install dependencies now', true)),
+            git: flags.git ?? true,
+            core,
+        };
+    }
+    finally {
+        p.close();
+    }
+}
+function write(o) {
+    // Checked before anything is written: the name is interpolated into
+    // generated source, and the directory decides where that source lands.
+    assertUsableName(o.name);
+    assertInsideCwd(o.dir, process.cwd());
+    // An existing directory is fine; an existing *app* is not. Overwriting
+    // someone's package.json to scaffold over it is not recoverable.
+    if (existsSync(join(o.dir, 'package.json'))) {
+        stdout.write(`\n${bold('There is already a package.json in ' + o.dir + '.')}\n`);
+        stdout.write(dim('  Choose an empty directory, or delete it first.\n'));
+        exit(1);
+    }
+    if (existsSync(o.dir) && readdirSync(o.dir).some((f) => !f.startsWith('.'))) {
+        stdout.write(`\n${dim(o.dir + ' is not empty; adding to it.')}\n`);
+    }
+    const files = [
+        ['package.json', t.packageJson(o)],
+        ['tsconfig.json', t.tsconfig(o)],
+        ['vite.config.ts', t.viteConfig(o)],
+        [t.serverFile(o.host), t.server(o.host)],
+        ['.gitignore', t.gitignore],
+        ['README.md', t.readme(o)],
+        ['src/app/layout.tsx', t.layout(o)],
+        ['src/app/page.tsx', t.page(o)],
+        ['src/components/Counter.tsx', t.counter(o)],
+    ];
+    if (o.tailwind)
+        files.push(['src/app/styles.css', t.styles]);
+    if (o.lint)
+        files.push(['.oxlintrc.json', t.oxlintConfig(o)]);
+    const replaced = [];
+    for (const [path, contents] of files) {
+        const full = join(o.dir, path);
+        // wx: create, or fail. Scaffolding into a directory that already holds a
+        // README, a .gitignore or a vite config used to replace them silently —
+        // and a .gitignore is exactly the file whose loss is noticed late. The
+        // package.json guard above does not cover them, and a directory holding
+        // only dotfiles did not even produce the "not empty" notice.
+        mkdirSync(dirname(full), { recursive: true });
+        try {
+            writeFileSync(full, contents, { flag: 'wx' });
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            replaced.push(path);
+        }
+    }
+    if (replaced.length > 0) {
+        stdout.write(`\n${bold('Left alone, because they already exist:')}\n`);
+        for (const path of replaced)
+            stdout.write(`  ${dim(path)}\n`);
+    }
+}
+function run(command, args, cwd) {
+    const result = spawnSync(command, args, { cwd, stdio: 'inherit' });
+    return result.status === 0;
+}
+function report(o) {
+    const pm = o.host === 'node' ? 'npm run' : 'bun run';
+    const steps = [
+        `cd ${relativeish(o.dir)}`,
+        ...(o.install ? [] : [o.host === 'node' ? 'npm install' : 'bun install']),
+        `${pm} build`,
+        `${pm} start`,
+    ];
+    stdout.write(`\n${bold('Done.')} ${dim(o.dir)}\n\n`);
+    for (const step of steps)
+        stdout.write(`  ${cyan(step)}\n`);
+    stdout.write(`\n${dim('The route tree is read at build time — rebuild after adding a page under src/app.')}\n\n`);
+}
+/** A path the user can paste, when it is under where they are. */
+function relativeish(dir) {
+    const cwd = process.cwd();
+    return dir.startsWith(cwd + '/') ? dir.slice(cwd.length + 1) : dir;
+}

package/dist/init.d.ts

@@ -0,0 +1,36 @@
+import type { Host, Options } from './options.js';
+export interface Detected {
+    /** What the project's package.json says it already depends on. */
+    deps: Record<string, string>;
+    host: Host | null;
+    sourceDir: string | null;
+    viteConfig: string | null;
+    hasReact: boolean;
+    hasTailwind: boolean;
+    hasTypeScript: boolean;
+    packageJson: Record<string, unknown>;
+}
+/** What a step did, for the report at the end. */
+export interface Step {
+    kind: 'wrote' | 'merged' | 'manual' | 'skipped';
+    what: string;
+    detail?: string;
+}
+/**
+ * What is already here.
+ *
+ * Every answer is a guess the caller can override — the point is to not ask
+ * about things the project has already decided.
+ */
+export declare function detect(dir: string): Detected;
+/** Everything, in the order a reader would want to hear about it. */
+export declare function initialise(o: Options, found: Detected, dir: string): Step[];
+/**
+ * Add RSC to a project that already exists.
+ *
+ * Almost everything is detected rather than asked: which server the project
+ * already uses, where its source lives, whether React and Tailwind are already
+ * there. A question about something the project has already decided is a
+ * question with a wrong answer available.
+ */
+export declare function runInit(args: string[]): Promise<void>;

package/dist/init.js

@@ -0,0 +1,286 @@
+// Adding RSC to a project that already exists.
+//
+// Scaffolding writes whatever it likes into an empty directory. This cannot:
+// the vite config, the server and package.json are already someone's, and they
+// are the three files most likely to hold work that took a while to get right.
+//
+// So the rule here is that nothing existing is ever rewritten. New files are
+// written, missing dependencies are added, and for anything already present
+// the exact edit is printed for the reader to make. A tool that silently
+// reformats a working server has to be right about more than it can know.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { cwd, exit, stdout } from 'node:process';
+import { DEFAULT_COMPILER, parseArgs } from './options.js';
+import { Prompter, bold, cyan, dim } from './prompt.js';
+import * as t from './templates.js';
+const HOST_PACKAGES = { hono: 'hono', elysia: 'elysia' };
+/**
+ * What is already here.
+ *
+ * Every answer is a guess the caller can override — the point is to not ask
+ * about things the project has already decided.
+ */
+export function detect(dir) {
+    const pkgPath = join(dir, 'package.json');
+    const packageJson = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    const deps = {
+        ...(packageJson.dependencies ?? {}),
+        ...(packageJson.devDependencies ?? {}),
+    };
+    let host = null;
+    for (const [pkg, value] of Object.entries(HOST_PACKAGES)) {
+        if (deps[pkg])
+            host = value;
+    }
+    // No framework named, so it comes down to which runtime's types are here.
+    // Bun is the default because a project with neither is more likely to be
+    // reaching for this from Bun than from bare node:http.
+    if (!host)
+        host = deps['@types/node'] && !deps['@types/bun'] ? 'node' : 'bun';
+    return {
+        deps,
+        host,
+        sourceDir: ['src', 'app', 'resources/js'].find((d) => existsSync(join(dir, d))) ?? null,
+        viteConfig: ['vite.config.ts', 'vite.config.js', 'vite.config.mts'].find((f) => existsSync(join(dir, f))) ?? null,
+        hasReact: Boolean(deps.react),
+        hasTailwind: Boolean(deps.tailwindcss),
+        hasTypeScript: existsSync(join(dir, 'tsconfig.json')),
+        packageJson,
+    };
+}
+/**
+ * Add the dependencies the engine needs, without touching versions already
+ * chosen. A project on React 19.3 does not want to be pinned back to ours.
+ */
+function mergeDependencies(o, found) {
+    const pkg = found.packageJson;
+    const wanted = JSON.parse(t.packageJson(o));
+    const steps = [];
+    const added = [];
+    for (const [field, incoming] of [
+        ['dependencies', wanted.dependencies],
+        ['devDependencies', wanted.devDependencies],
+    ]) {
+        const current = pkg[field] ?? {};
+        for (const [name, range] of Object.entries(incoming)) {
+            // Already declared anywhere: leave it exactly as it is.
+            if (found.deps[name])
+                continue;
+            current[name] = range;
+            added.push(name);
+        }
+        if (Object.keys(current).length > 0) {
+            pkg[field] = Object.fromEntries(Object.entries(current).sort(([a], [b]) => a.localeCompare(b)));
+        }
+    }
+    steps.push(added.length > 0
+        ? { kind: 'merged', what: 'package.json', detail: `added ${added.join(', ')}` }
+        : { kind: 'skipped', what: 'package.json dependencies', detail: 'everything needed is already here' });
+    return steps;
+}
+/**
+ * Scripts, but never over one that exists.
+ *
+ * `dev` and `build` are the two most likely to already mean something, and
+ * quietly replacing either is how a tool loses someone's trust permanently.
+ */
+function mergeScripts(o, found) {
+    const pkg = found.packageJson;
+    const scripts = pkg.scripts ?? {};
+    const wanted = JSON.parse(t.packageJson(o)).scripts;
+    const added = [];
+    const conflicts = [];
+    for (const [name, command] of Object.entries(wanted)) {
+        if (scripts[name] === undefined) {
+            scripts[name] = command;
+            added.push(name);
+        }
+        else if (scripts[name] !== command) {
+            conflicts.push(`${name}: ${command}`);
+        }
+    }
+    pkg.scripts = scripts;
+    const steps = [];
+    if (added.length > 0)
+        steps.push({ kind: 'merged', what: 'scripts', detail: added.join(', ') });
+    if (conflicts.length > 0) {
+        steps.push({
+            kind: 'manual',
+            what: 'scripts you already have',
+            detail: `left alone — add these yourself if you want them:\n      ${conflicts.join('\n      ')}`,
+        });
+    }
+    return steps;
+}
+/** The plugin entry, written if there is no config and printed if there is. */
+function viteConfig(o, found, dir) {
+    if (found.viteConfig === null) {
+        writeFileSync(join(dir, 'vite.config.ts'), t.viteConfig(o));
+        return [{ kind: 'wrote', what: 'vite.config.ts' }];
+    }
+    return [
+        {
+            kind: 'manual',
+            what: found.viteConfig,
+            detail: `add the plugin — it must come before any react() layer:\n` +
+                `      import { rscRoutes } from '@rsc-kit/core/vite'\n\n` +
+                `      plugins: [\n` +
+                `        rscRoutes({ sourceDir: '${o.sourceDir}', outDir: 'build', assetsDir: 'build/public' }),\n` +
+                `        …whatever you already have\n` +
+                `      ]`,
+        },
+    ];
+}
+/** The server: written only when there is nothing there to break. */
+function server(o, dir) {
+    const file = t.serverFile(o.host);
+    if (existsSync(join(dir, file))) {
+        return [
+            {
+                kind: 'manual',
+                what: file,
+                detail: 'left alone. Mount the handler in it — anything the route table does not\n' +
+                    '      claim comes back null, so your own routes still win:\n\n' +
+                    t
+                        .server(o.host)
+                        .split('\n')
+                        .map((line) => '      ' + line)
+                        .join('\n'),
+            },
+        ];
+    }
+    writeFileSync(join(dir, file), t.server(o.host));
+    return [{ kind: 'wrote', what: file }];
+}
+/** The route tree, only where there is not one already. */
+function routes(o, dir) {
+    const appDir = join(dir, o.sourceDir, 'app');
+    const steps = [];
+    if (existsSync(join(appDir, 'layout.tsx')) || existsSync(join(appDir, 'page.tsx'))) {
+        return [{ kind: 'skipped', what: `${o.sourceDir}/app`, detail: 'a route tree is already here' }];
+    }
+    const files = [
+        [join(o.sourceDir, 'app/layout.tsx'), t.layout(o)],
+        [join(o.sourceDir, 'app/page.tsx'), t.page(o)],
+        [join(o.sourceDir, 'components/Counter.tsx'), t.counter(o)],
+    ];
+    if (o.tailwind)
+        files.push([join(o.sourceDir, 'app/styles.css'), t.styles]);
+    for (const [path, contents] of files) {
+        const full = join(dir, path);
+        if (existsSync(full)) {
+            steps.push({ kind: 'skipped', what: path, detail: 'already exists' });
+            continue;
+        }
+        mkdirSync(dirname(full), { recursive: true });
+        writeFileSync(full, contents);
+        steps.push({ kind: 'wrote', what: path });
+    }
+    return steps;
+}
+/** Ignore the files the build rewrites into the source dir on every run. */
+function gitignore(o, dir) {
+    const path = join(dir, '.gitignore');
+    const generated = ['rsc-env.d.ts', 'rsc-types.d.ts', 'rsc-routes.d.ts', 'rsc-engine.d.ts'].map((f) => `${o.sourceDir}/${f}`);
+    const current = existsSync(path) ? readFileSync(path, 'utf-8') : '';
+    const missing = generated.filter((line) => !current.includes(line));
+    if (missing.length === 0)
+        return [{ kind: 'skipped', what: '.gitignore', detail: 'already covers the generated files' }];
+    writeFileSync(path, current + (current.endsWith('\n') || current === '' ? '' : '\n') +
+        '\n# Written into the source dir by the RSC build, every run.\n' +
+        missing.join('\n') + '\nbuild\n');
+    return [{ kind: 'merged', what: '.gitignore', detail: `added ${missing.length} generated paths` }];
+}
+/** Everything, in the order a reader would want to hear about it. */
+export function initialise(o, found, dir) {
+    const steps = [
+        ...routes(o, dir),
+        ...viteConfig(o, found, dir),
+        ...server(o, dir),
+        ...gitignore(o, dir),
+        ...mergeDependencies(o, found),
+        ...mergeScripts(o, found),
+    ];
+    writeFileSync(join(dir, 'package.json'), JSON.stringify(found.packageJson, null, 2) + '\n');
+    return steps;
+}
+const INIT_HELP = `
+  rsc-kit init — add RSC to the project in this directory
+
+  Nothing existing is ever rewritten. New files are written, missing
+  dependencies are added, and for anything already there the exact edit is
+  printed for you to make.
+
+  Options
+    --source-dir <dir>   where app/ should live (detected, usually src)
+    --host=…             bun | hono | elysia | node (detected from your deps)
+    --compiler=…         none | oxc | babel
+    --tailwind           add Tailwind as well
+    -y, --yes            accept what was detected, ask nothing
+    -h, --help           this
+`;
+/**
+ * Add RSC to a project that already exists.
+ *
+ * Almost everything is detected rather than asked: which server the project
+ * already uses, where its source lives, whether React and Tailwind are already
+ * there. A question about something the project has already decided is a
+ * question with a wrong answer available.
+ */
+export async function runInit(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        stdout.write(INIT_HELP);
+        return;
+    }
+    const dir = cwd();
+    if (!existsSync(join(dir, 'package.json'))) {
+        stdout.write(`\n${bold('No package.json here.')}\n` +
+            `  init adds RSC to a project that already exists. To start a new one:\n` +
+            `  ${cyan('bun create rsc-kit my-app')}\n\n`);
+        exit(1);
+    }
+    const flags = parseArgs(args);
+    const found = detect(dir);
+    const unattended = args.includes('-y') || args.includes('--yes') || flags.host !== undefined;
+    stdout.write(`\n${bold('Adding rsc-kit')} ${dim(dir)}\n\n`);
+    stdout.write(`  ${dim('server')}      ${found.host}${flags.host ? '' : dim('  (detected)')}\n`);
+    stdout.write(`  ${dim('source')}      ${flags.sourceDir ?? found.sourceDir ?? 'src'}\n`);
+    stdout.write(`  ${dim('react')}       ${found.hasReact ? 'already here' : 'will be added'}\n\n`);
+    let compiler = flags.compiler ?? 'none';
+    let tailwind = flags.tailwind ?? found.hasTailwind;
+    if (!unattended) {
+        const p = new Prompter();
+        try {
+            compiler = flags.compiler ?? ((await p.confirm('React Compiler', true)) ? DEFAULT_COMPILER : 'none');
+            if (flags.tailwind === undefined && !found.hasTailwind) {
+                tailwind = await p.confirm('Tailwind CSS', false);
+            }
+        }
+        finally {
+            p.close();
+        }
+    }
+    const options = {
+        dir,
+        name: 'app',
+        host: flags.host ?? found.host ?? 'bun',
+        compiler,
+        tailwind,
+        lint: false,
+        sourceDir: flags.sourceDir ?? found.sourceDir ?? 'src',
+        install: false,
+        git: false,
+        core: flags.core ?? '^0.1.0',
+    };
+    const steps = initialise(options, found, dir);
+    const mark = { wrote: cyan('+'), merged: cyan('~'), manual: bold('!'), skipped: dim('·') };
+    stdout.write(`${bold('Done.')}\n\n`);
+    for (const step of steps) {
+        stdout.write(`  ${mark[step.kind]} ${step.what}${step.detail ? dim('  — ' + step.detail) : ''}\n`);
+    }
+    const manual = steps.filter((s) => s.kind === 'manual');
+    stdout.write(manual.length > 0
+        ? `\n${bold('Then, by hand:')} the edits marked ! above are in files you already had.\n\n`
+        : `\n  ${cyan('bun install')} and you are ready.\n\n`);
+}

package/dist/options.d.ts

@@ -0,0 +1,55 @@
+export type Host = 'bun' | 'hono' | 'elysia' | 'node';
+export type Compiler = 'none' | 'oxc' | 'babel';
+export interface Options {
+    dir: string;
+    name: string;
+    host: Host;
+    compiler: Compiler;
+    tailwind: boolean;
+    lint: boolean;
+    /** Where the app/ route tree lives, relative to the project. */
+    sourceDir: string;
+    install: boolean;
+    git: boolean;
+    /** What to depend on for the engine. A path makes a local checkout testable. */
+    core: string;
+}
+export declare const HOSTS: {
+    value: Host;
+    label: string;
+    hint: string;
+}[];
+/**
+ * Not asked as a three-way.
+ *
+ * The compiler has a native implementation and a Babel one, and they produce
+ * the same transform — one is just faster to run. Asking which is asking the
+ * user to make a build-performance decision on our behalf, in a project whose
+ * whole argument is performance. So the prompt is yes/no and the answer is
+ * oxc; `--compiler=babel` is there for when the experimental one misbehaves.
+ */
+export declare const DEFAULT_COMPILER: Compiler;
+/** The published version range, when there is no checkout to prefer. */
+export declare const PUBLISHED_CORE = "^0.1.0";
+/**
+ * What to depend on for the engine.
+ *
+ * Run from a checkout — linked, or straight out of the repo — the sibling
+ * package is what the author means, and pointing at npm instead fails the
+ * install on a version that may not exist yet. Installed from npm there is no
+ * sibling and the range is right.
+ */
+export declare function defaultCore(fromDir: string): string;
+export declare function parseArgs(argv: string[]): Partial<Options> & {
+    help?: boolean;
+    init?: boolean;
+};
+export declare function assertUsableName(name: string): void;
+/**
+ * Where the app is written, refusing anywhere that is not below here.
+ *
+ * A generator that writes outside the directory it was pointed at is a
+ * generator nobody can run without reading it first.
+ */
+export declare function assertInsideCwd(dir: string, cwd: string): void;
+export declare const HELP = "\n  create-rsc-kit \u2014 scaffold an RSC app\n\n  Usage\n    create-rsc-kit <dir> [options]\n    bun create rsc-kit <dir> [options]   (once published)\n\n  Options\n    --host=bun|hono|elysia|node   which server to generate\n    --compiler=none|oxc|babel     React Compiler (prompt offers oxc; babel by flag)\n    --tailwind / --no-tailwind    include Tailwind\n    --lint / --no-lint            include oxlint\n    --source-dir <dir>            where app/ lives (default: src)\n    --init                        add to the project here, rather than scaffold\n    --core=<spec>                 engine dependency, e.g. file:../rsc-kit/packages/core\n    --no-install                  skip installing dependencies\n    --no-git                      skip git init\n    -y, --yes                     accept every default, ask nothing\n    -h, --help                    this\n";