create-shape-app 0.1.3 → 0.1.5

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { type PackageManager } from './cli/args.js';
 import { type PostScaffoldSetupOptions, type PostScaffoldSetupResult } from './scaffold/post-setup.js';
 import { type MaterializedTemplate } from './template/materialize.js';
 import { type TemplateRelease } from './template/release.js';
@@ -10,6 +11,7 @@ interface CliRuntime {
     print: (message: string) => void;
     printError: (message: string) => void;
     prompt: (message: string) => Promise<string>;
+    selectPackageManager: (options: PackageManagerSelectOptions) => Promise<PackageManager | undefined>;
     confirm: (message: string) => Promise<boolean>;
     resolveTemplateRelease: (templateRef?: string) => Promise<TemplateRelease>;
     materializeTemplate: (release: TemplateRelease) => Promise<MaterializedTemplate>;
@@ -17,5 +19,10 @@ interface CliRuntime {
     copyTemplateToDirectory: (templateRoot: string, targetDirectory: string) => Promise<void>;
     runPostScaffoldSetup: (options: PostScaffoldSetupOptions) => Promise<PostScaffoldSetupResult>;
 }
+interface PackageManagerSelectOptions {
+    message: string;
+    choices: readonly PackageManager[];
+    defaultValue: PackageManager;
+}
 export declare function runCLI(argv: string[], runtimeOverrides?: Partial<CliRuntime>): Promise<number>;
 export {};

package/dist/index.js

@@ -1,7 +1,8 @@
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { createRequire } from 'node:module';
-import readline from 'node:readline/promises';
+import { createInterface } from 'node:readline/promises';
+import { clearScreenDown, cursorTo, emitKeypressEvents, moveCursor } from 'node:readline';
 import { parseArgs } from './cli/args.js';
 import { CliUsageError } from './cli/errors.js';
 import { HELP_TEXT } from './cli/help.js';
@@ -13,9 +14,9 @@ const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
 export const CLI_VERSION = packageJson.version ?? '0.0.0';
 const PACKAGE_MANAGERS = ['npm', 'pnpm', 'yarn', 'bun'];
-const PACKAGE_MANAGER_SET = new Set(PACKAGE_MANAGERS);
 const DEFAULT_PROJECT_NAME_PROMPT = 'Project name: ';
 const DEFAULT_CONFIRM_PROMPT = 'Continue? (Y/n): ';
+const PACKAGE_MANAGER_SELECT_MESSAGE = 'Package manager:';
 export async function runCLI(argv, runtimeOverrides = {}) {
     const runtime = createRuntime(runtimeOverrides);
     try {
@@ -110,6 +111,7 @@ function createRuntime(overrides) {
         print: console.log,
         printError: console.error,
         prompt: defaultPrompt,
+        selectPackageManager: defaultSelectPackageManager,
         confirm: defaultConfirm,
         resolveTemplateRelease: (templateRef) => fetchTemplateRelease({
             templateRef,
@@ -141,35 +143,17 @@ async function resolvePackageManager(packageManager, skipPrompts, runtime) {
     if (!isInteractive(runtime) || skipPrompts) {
         return detectedPackageManager;
     }
-    runtime.print('Package manager:');
-    for (const [index, candidate] of PACKAGE_MANAGERS.entries()) {
-        const defaultLabel = candidate === detectedPackageManager ? ' (default)' : '';
-        runtime.print(`  ${index + 1}) ${candidate}${defaultLabel}`);
-    }
-    while (true) {
-        const answer = (await runtime.prompt(`Select package manager (1-${PACKAGE_MANAGERS.length}) [${detectedPackageManager}]: `))
-            .trim()
-            .toLowerCase();
-        if (!answer) {
-            return detectedPackageManager;
-        }
-        const selectedByIndex = Number(answer);
-        if (Number.isInteger(selectedByIndex) &&
-            selectedByIndex >= 1 &&
-            selectedByIndex <= PACKAGE_MANAGERS.length) {
-            return PACKAGE_MANAGERS[selectedByIndex - 1];
-        }
-        if (PACKAGE_MANAGER_SET.has(answer)) {
-            return answer;
-        }
-        runtime.printError(`Invalid package manager: ${answer}. Enter 1-${PACKAGE_MANAGERS.length} or one of ${PACKAGE_MANAGERS.join(', ')}.`);
-    }
+    return ((await runtime.selectPackageManager({
+        message: PACKAGE_MANAGER_SELECT_MESSAGE,
+        choices: PACKAGE_MANAGERS,
+        defaultValue: detectedPackageManager,
+    })) ?? detectedPackageManager);
 }
 function isInteractive(runtime) {
     return runtime.stdinIsTTY && runtime.stdoutIsTTY;
 }
 async function defaultPrompt(message) {
-    const rl = readline.createInterface({
+    const rl = createInterface({
         input: process.stdin,
         output: process.stdout,
     });
@@ -185,6 +169,94 @@ async function defaultConfirm(message) {
     const normalized = answer.trim().toLowerCase();
     return normalized === '' || normalized === 'y' || normalized === 'yes';
 }
+async function defaultSelectPackageManager(options) {
+    const { message, choices, defaultValue } = options;
+    if (choices.length === 0) {
+        return undefined;
+    }
+    const defaultIndex = choices.indexOf(defaultValue);
+    let selectedIndex = defaultIndex >= 0 ? defaultIndex : 0;
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return choices[selectedIndex];
+    }
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    const previousRawMode = Boolean(stdin.isRaw);
+    let renderedLines = 0;
+    const render = () => {
+        const lines = [
+            message,
+            ...choices.map((candidate, index) => {
+                const indicator = index === selectedIndex ? '>' : ' ';
+                const defaultLabel = candidate === defaultValue ? ' (default)' : '';
+                return ` ${indicator} ${candidate}${defaultLabel}`;
+            }),
+            '  Use Up/Down arrows and Enter to confirm.',
+        ];
+        if (renderedLines > 0) {
+            moveCursor(stdout, 0, -renderedLines);
+            cursorTo(stdout, 0);
+            clearScreenDown(stdout);
+        }
+        stdout.write(lines.join('\n'));
+        stdout.write('\n');
+        renderedLines = lines.length;
+    };
+    emitKeypressEvents(stdin);
+    if (typeof stdin.setRawMode === 'function') {
+        stdin.setRawMode(true);
+    }
+    stdin.resume();
+    stdout.write('\x1b[?25l');
+    render();
+    try {
+        const selected = await new Promise((resolve, reject) => {
+            const onKeypress = (_value, key) => {
+                if (!key) {
+                    return;
+                }
+                if (key.ctrl && key.name === 'c') {
+                    stdin.off('keypress', onKeypress);
+                    reject(new Error('Aborted.'));
+                    return;
+                }
+                if (key.name === 'up' || key.name === 'k') {
+                    selectedIndex = (selectedIndex - 1 + choices.length) % choices.length;
+                    render();
+                    return;
+                }
+                if (key.name === 'down' || key.name === 'j') {
+                    selectedIndex = (selectedIndex + 1) % choices.length;
+                    render();
+                    return;
+                }
+                if (key.name === 'return' || key.name === 'enter') {
+                    stdin.off('keypress', onKeypress);
+                    resolve(choices[selectedIndex]);
+                    return;
+                }
+                if (key.name === 'escape') {
+                    stdin.off('keypress', onKeypress);
+                    resolve(defaultValue);
+                }
+            };
+            stdin.on('keypress', onKeypress);
+        });
+        if (renderedLines > 0) {
+            moveCursor(stdout, 0, -renderedLines);
+            cursorTo(stdout, 0);
+            clearScreenDown(stdout);
+        }
+        stdout.write(`Package manager: ${selected}\n`);
+        return selected;
+    }
+    finally {
+        stdout.write('\x1b[?25h');
+        if (typeof stdin.setRawMode === 'function') {
+            stdin.setRawMode(previousRawMode);
+        }
+    }
+}
 function assertValidProjectName(projectName) {
     if (projectName === '.' || projectName === '..') {
         throw new CliUsageError('Invalid project name: "." and ".." are not allowed.');

package/dist/template/release.js

@@ -23,10 +23,11 @@ export async function fetchTemplateRelease(options = {}) {
     const endpoint = templateRef
         ? `https://api.github.com/repos/${owner}/${repo}/releases/tags/${encodeURIComponent(templateRef)}`
         : `https://api.github.com/repos/${owner}/${repo}/releases/latest`;
+    const headers = buildHeaders(githubToken);
     let response;
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
         response = await fetchImpl(endpoint, {
-            headers: buildHeaders(githubToken),
+            headers,
         });
         if (response.ok) {
             break;
@@ -40,6 +41,49 @@ export async function fetchTemplateRelease(options = {}) {
         throw new Error('Failed to resolve template release: no response received.');
     }
     if (!response.ok) {
+        if (response.status === 404) {
+            if (templateRef) {
+                const resolvedTag = await resolveTemplateRefTag({
+                    owner,
+                    repo,
+                    templateRef,
+                    githubToken,
+                    fetchImpl,
+                });
+                if (resolvedTag) {
+                    return {
+                        tag: resolvedTag,
+                        tarballUrl: buildTagTarballUrl(owner, repo, resolvedTag),
+                    };
+                }
+            }
+            else {
+                const latestTag = await resolveLatestSupportedTag({
+                    owner,
+                    repo,
+                    githubToken,
+                    fetchImpl,
+                });
+                if (latestTag) {
+                    return {
+                        tag: latestTag,
+                        tarballUrl: buildTagTarballUrl(owner, repo, latestTag),
+                    };
+                }
+                const defaultBranch = await resolveDefaultBranch({
+                    owner,
+                    repo,
+                    githubToken,
+                    fetchImpl,
+                });
+                if (defaultBranch) {
+                    return {
+                        tag: defaultBranch,
+                        tarballUrl: buildTagTarballUrl(owner, repo, defaultBranch),
+                    };
+                }
+            }
+        }
         throw new Error(await buildReleaseLookupError(response, templateRef));
     }
     const payload = (await response.json());
@@ -54,6 +98,9 @@ export async function fetchTemplateRelease(options = {}) {
         tarballUrl,
     };
 }
+function buildTagTarballUrl(owner, repo, tag) {
+    return `https://api.github.com/repos/${owner}/${repo}/tarball/${encodeURIComponent(tag)}`;
+}
 function buildHeaders(githubToken) {
     const headers = {
         Accept: 'application/vnd.github+json',
@@ -84,6 +131,64 @@ async function buildReleaseLookupError(response, templateRef) {
     }
     return `Failed to resolve ${refLabel}: HTTP ${response.status}.`;
 }
+async function resolveLatestSupportedTag(options) {
+    const tags = await fetchTagNames(options);
+    return tags.find((tag) => isSupportedTag(tag));
+}
+async function resolveTemplateRefTag(options) {
+    const tags = await fetchTagNames(options);
+    const exactMatch = tags.find((tag) => tag === options.templateRef && isSupportedTag(tag));
+    if (exactMatch) {
+        return exactMatch;
+    }
+    const normalizedTemplateRef = normalizeTag(options.templateRef);
+    return tags.find((tag) => normalizeTag(tag) === normalizedTemplateRef && isSupportedTag(tag));
+}
+async function fetchTagNames(options) {
+    const response = await options.fetchImpl(`https://api.github.com/repos/${options.owner}/${options.repo}/tags?per_page=100`, {
+        headers: buildHeaders(options.githubToken),
+    });
+    if (!response.ok) {
+        return [];
+    }
+    const payload = (await response.json());
+    if (!Array.isArray(payload)) {
+        return [];
+    }
+    return payload.flatMap((item) => {
+        if (!item || typeof item !== 'object') {
+            return [];
+        }
+        const name = item.name;
+        return typeof name === 'string' && name.trim() ? [name] : [];
+    });
+}
+async function resolveDefaultBranch(options) {
+    const response = await options.fetchImpl(`https://api.github.com/repos/${options.owner}/${options.repo}`, {
+        headers: buildHeaders(options.githubToken),
+    });
+    if (!response.ok) {
+        return undefined;
+    }
+    const payload = (await response.json());
+    const defaultBranch = payload.default_branch;
+    if (typeof defaultBranch !== 'string' || !defaultBranch.trim()) {
+        return undefined;
+    }
+    return defaultBranch;
+}
+function isSupportedTag(tag) {
+    try {
+        assertTagIsSupported(tag);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeTag(tag) {
+    return tag.startsWith('v') ? tag.slice(1) : tag;
+}
 async function readApiMessage(response) {
     try {
         const payload = (await response.clone().json());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-shape-app",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Scaffold Shape Builder Kit projects from pinned release tags.",
   "license": "MIT",
   "repository": {