create-hsi-app 0.2.0 → 0.5.2

package/README.md

@@ -28,8 +28,5 @@ pnpm create hsi-app@latest
 bun create hsi-app@latest
 ```
 
-Pass the package manager flag after the initializer:
-
-```bash
-npm create hsi-app@latest -- --pnpm
-```
+Full CLI usage, flags, and repo/install behavior:
+[docs/create-hsi-app.md](https://github.com/Hsiii/frontend-template/blob/main/docs/create-hsi-app.md)

package/bin/create-hsi-app.mjs

@@ -8,58 +8,99 @@ import {
     writeFileSync,
 } from 'node:fs';
 import { basename, join, resolve } from 'node:path';
+import { stdin as input, stdout as output } from 'node:process';
+import readline from 'node:readline/promises';
 
 const templateRepo = 'https://github.com/Hsiii/frontend-template.git';
-const templateTag = 'v0.2.0';
+const templateTag = 'v0.5.2';
 const defaultAppName = 'my-app';
 const packageManagers = ['bun', 'npm', 'pnpm', 'yarn'];
 const rawArgs = process.argv.slice(2);
-const selectedPackageManager = parsePackageManagerFlag(rawArgs);
-const targetArg = rawArgs.find((arg) => !arg.startsWith('--')) ?? '.';
+const parsedArgs = parseCliArgs(rawArgs);
+const selectedPackageManager = resolvePackageManager(parsedArgs);
+const shouldInstallDependencies = !(
+    parsedArgs.noInstall || readNpmBooleanFlag('noinstall')
+);
+const shouldSkipRepoSetup = parsedArgs.noRepo || readNpmBooleanFlag('norepo');
+const isInteractive = input.isTTY && output.isTTY;
+const targetArg = parsedArgs.targetArg ?? '.';
 const targetPath = resolve(targetArg);
 const appName = toPackageName(basename(targetPath));
 
-if (existsSync(targetPath) && readdirSync(targetPath).length > 0) {
-    fail(`Target directory is not empty: ${targetPath}`);
-}
+main().catch((error) => {
+    fail(error.message);
+});
+
+async function main() {
+    if (existsSync(targetPath) && readdirSync(targetPath).length > 0) {
+        fail(`Target directory is not empty: ${targetPath}`);
+    }
+
+    run('git', [
+        '-c',
+        'advice.detachedHead=false',
+        'clone',
+        '--branch',
+        templateTag,
+        '--depth',
+        '1',
+        templateRepo,
+        targetPath,
+    ]);
+
+    rmSync(join(targetPath, '.git'), { force: true, recursive: true });
+    rmSync(join(targetPath, '.github'), { force: true, recursive: true });
+    rmSync(join(targetPath, 'docs'), { force: true, recursive: true });
+    rmSync(join(targetPath, 'packages'), { force: true, recursive: true });
+    rmSync(join(targetPath, 'scripts'), { force: true, recursive: true });
+
+    updatePackageJson();
+    updateBunLock();
+    updateAppText();
+    updatePackageManagerFiles();
+    writeAppReadme();
+
+    if (shouldInstallDependencies) {
+        installDependencies();
+    }
 
-run('git', [
-    '-c',
-    'advice.detachedHead=false',
-    'clone',
-    '--branch',
-    templateTag,
-    '--depth',
-    '1',
-    templateRepo,
-    targetPath,
-]);
-
-rmSync(join(targetPath, '.git'), { force: true, recursive: true });
-rmSync(join(targetPath, '.github'), { force: true, recursive: true });
-rmSync(join(targetPath, 'docs'), { force: true, recursive: true });
-rmSync(join(targetPath, 'packages'), { force: true, recursive: true });
-rmSync(join(targetPath, 'scripts'), { force: true, recursive: true });
-
-updatePackageJson();
-updateBunLock();
-updateAppText();
-updatePackageManagerFiles();
-writeAppReadme();
-
-console.log(`\nCreated ${appName} in ${targetPath}\n`);
-console.log('Next steps:');
-if (targetArg !== '.') {
-    console.log(`  cd ${targetArg}`);
+    const repoSetup = await maybeSetupRepo();
+
+    console.log(`\nCreated ${appName} in ${targetPath}\n`);
+    if (repoSetup === 'github') {
+        console.log(
+            'Created a local git repository and configured GitHub origin.'
+        );
+    } else if (repoSetup === 'local') {
+        console.log('Initialized a local git repository.');
+    }
+    if (shouldInstallDependencies) {
+        console.log(`Installed dependencies with ${selectedPackageManager}.`);
+    }
+    console.log('\nNext steps:');
+    if (targetArg !== '.') {
+        console.log(`  cd ${targetArg}`);
+    }
+    if (!shouldInstallDependencies) {
+        console.log(`  ${installCommand()}`);
+    }
+    console.log(`  ${devCommand()}`);
 }
-console.log(`  ${installCommand()}`);
-console.log(`  ${devCommand()}`);
 
-function run(command, args) {
+function run(command, args, options = {}) {
     try {
-        execFileSync(command, args, { stdio: 'inherit' });
-    } catch {
-        fail(`Failed to run: ${command} ${args.join(' ')}`);
+        return execFileSync(command, args, {
+            cwd: options.cwd,
+            encoding: options.capture ? 'utf8' : undefined,
+            stdio: options.capture ? 'pipe' : 'inherit',
+        });
+    } catch (error) {
+        if (options.allowFailure) {
+            return null;
+        }
+
+        const details = error.stderr?.toString().trim() || error.message;
+        fail(`Failed to run: ${command} ${args.join(' ')}\n${details}`);
     }
 }
 
@@ -73,6 +114,7 @@ function updatePackageJson() {
     delete packageJson.publishConfig;
     delete packageJson.packageManager;
     delete packageJson.engines;
+    delete packageJson.scripts.prepare;
     delete packageJson.scripts.release;
     packageJson.scripts.check =
         'tsc -p tsconfig.json --noEmit && eslint . && prettier . --check && vite build';
@@ -151,6 +193,25 @@ function updatePackageManagerFiles() {
     }
 }
 
+function installDependencies() {
+    switch (selectedPackageManager) {
+        case 'bun':
+            run('bun', ['install'], { cwd: targetPath });
+            return;
+        case 'npm':
+            run('npm', ['install'], { cwd: targetPath });
+            return;
+        case 'pnpm':
+            run('pnpm', ['install'], { cwd: targetPath });
+            return;
+        case 'yarn':
+            run('yarn', ['install'], { cwd: targetPath });
+            return;
+        default:
+            fail(`Unsupported package manager: ${selectedPackageManager}`);
+    }
+}
+
 function writeAppReadme() {
     const installLine = installCommand();
     const devLine = devCommand();
@@ -184,6 +245,133 @@ ${securityNote}
     writeFileSync(join(targetPath, 'README.md'), readme);
 }
 
+async function maybeSetupRepo() {
+    if (shouldSkipRepoSetup || !isInteractive) {
+        return null;
+    }
+
+    const rl = readline.createInterface({ input, output });
+
+    try {
+        const shouldCreateRepo = await promptYesNo(
+            rl,
+            'Create a git repository?',
+            true
+        );
+
+        if (!shouldCreateRepo) {
+            return null;
+        }
+
+        initLocalRepo();
+
+        if (!canUseGitHubCli()) {
+            return 'local';
+        }
+
+        const defaultRepoName = basename(targetPath);
+        const repoName = await promptWithDefault(
+            rl,
+            'Repository name',
+            defaultRepoName
+        );
+        const visibility = await promptChoice(rl, 'Visibility', [
+            { label: 'private', value: 'private', default: true },
+            { label: 'public', value: 'public' },
+        ]);
+
+        run(
+            'gh',
+            [
+                'repo',
+                'create',
+                repoName,
+                `--${visibility}`,
+                '--source=.',
+                '--remote=origin',
+            ],
+            { cwd: targetPath }
+        );
+
+        return 'github';
+    } finally {
+        rl.close();
+    }
+}
+
+function initLocalRepo() {
+    run('git', ['init', '-b', 'main'], { cwd: targetPath });
+    run('git', ['config', 'core.hooksPath', '.githooks'], { cwd: targetPath });
+}
+
+function canUseGitHubCli() {
+    return Boolean(
+        run('gh', ['auth', 'status'], {
+            cwd: targetPath,
+            capture: true,
+            allowFailure: true,
+        })
+    );
+}
+
+async function promptYesNo(rl, label, defaultValue) {
+    const hint = defaultValue ? 'Y/n' : 'y/N';
+
+    while (true) {
+        const answer = (await rl.question(`${label} [${hint}] `))
+            .trim()
+            .toLowerCase();
+
+        if (!answer) {
+            return defaultValue;
+        }
+
+        if (['y', 'yes'].includes(answer)) {
+            return true;
+        }
+
+        if (['n', 'no'].includes(answer)) {
+            return false;
+        }
+    }
+}
+
+async function promptWithDefault(rl, label, defaultValue) {
+    const answer = (await rl.question(`${label} (${defaultValue}): `)).trim();
+
+    return answer || defaultValue;
+}
+
+async function promptChoice(rl, label, choices) {
+    const renderedChoices = choices
+        .map((choice) =>
+            choice.default ? `${choice.label.toUpperCase()}` : choice.label
+        )
+        .join('/');
+
+    while (true) {
+        const answer = (await rl.question(`${label} (${renderedChoices}): `))
+            .trim()
+            .toLowerCase();
+
+        if (!answer) {
+            const defaultChoice = choices.find((choice) => choice.default);
+
+            if (defaultChoice) {
+                return defaultChoice.value;
+            }
+        }
+
+        const matchingChoice = choices.find(
+            (choice) => choice.label === answer || choice.value === answer
+        );
+
+        if (matchingChoice) {
+            return matchingChoice.value;
+        }
+    }
+}
+
 function replaceInFile(filePath, searchValue, replacement) {
     const source = readFileSync(filePath, 'utf8');
     writeFileSync(filePath, source.replace(searchValue, replacement.with));
@@ -201,28 +389,69 @@ function toPackageName(value) {
     return name || defaultAppName;
 }
 
-function parsePackageManagerFlag(args) {
-    const selectedFlags = args.filter((arg) =>
-        ['--bun', '--npm', '--pnpm', '--yarn'].includes(arg)
-    );
+function parseCliArgs(args) {
+    const parsedArgs = {
+        noInstall: false,
+        noRepo: false,
+        packageManager: null,
+        targetArg: null,
+    };
+
+    for (const arg of args) {
+        switch (arg) {
+            case '--bun':
+                setPackageManagerOverride(parsedArgs, 'bun');
+                continue;
+            case '--npm':
+                setPackageManagerOverride(parsedArgs, 'npm');
+                continue;
+            case '--pnpm':
+                setPackageManagerOverride(parsedArgs, 'pnpm');
+                continue;
+            case '--yarn':
+                setPackageManagerOverride(parsedArgs, 'yarn');
+                continue;
+            case '--noInstall':
+                parsedArgs.noInstall = true;
+                continue;
+            case '--noRepo':
+                parsedArgs.noRepo = true;
+                continue;
+            default:
+                if (arg.startsWith('--')) {
+                    fail(`Unsupported option: ${arg}`);
+                }
+
+                if (parsedArgs.targetArg) {
+                    fail(`Unexpected argument: ${arg}`);
+                }
+
+                parsedArgs.targetArg = arg;
+        }
+    }
 
-    if (selectedFlags.length > 1) {
+    return parsedArgs;
+}
+
+function setPackageManagerOverride(parsedArgs, packageManager) {
+    if (
+        parsedArgs.packageManager &&
+        parsedArgs.packageManager !== packageManager
+    ) {
         fail('Pass only one of --bun, --npm, --pnpm, or --yarn.');
     }
 
-    switch (selectedFlags[0]) {
-        case '--npm':
-            return 'npm';
-        case '--pnpm':
-            return 'pnpm';
-        case '--yarn':
-            return 'yarn';
-        case '--bun':
-        case undefined:
-            return 'bun';
-        default:
-            fail(`Unsupported package manager flag: ${selectedFlags[0]}`);
-    }
+    parsedArgs.packageManager = packageManager;
+}
+
+function resolvePackageManager(parsedArgs) {
+    return parsedArgs.packageManager ?? 'bun';
+}
+
+function readNpmBooleanFlag(name) {
+    const value = process.env[`npm_config_${name}`];
+
+    return value === 'true' || value === '';
 }
 
 function packageManagerDeclaration() {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "create-hsi-app",
-    "version": "0.2.0",
+    "version": "0.5.2",
     "type": "module",
     "description": "Create a new app from the frontend template.",
     "bin": {