create-fugi 1.0.0

package/dist/commands/create.js

@@ -0,0 +1,63 @@
+import { rm, mkdtemp } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { input, select } from '@inquirer/prompts';
+import { downloadTemplatesDirectory as downloadTemplatesDirectoryFromGithub, } from '../lib/github.js';
+import { copyTemplate, ensureDirectoryDoesNotExist, listTemplates, validateProjectName, } from '../lib/templates.js';
+async function promptTemplateName(templates) {
+    return select({
+        message: 'Select a scaffold template',
+        choices: templates.map((template) => ({
+            name: template.name,
+            value: template.name,
+        })),
+    });
+}
+async function promptProjectName() {
+    return input({
+        message: 'Project name',
+        validate: (value) => {
+            try {
+                validateProjectName(value);
+                return true;
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    return error.message;
+                }
+                return 'Invalid project name.';
+            }
+        },
+    });
+}
+export async function runCreateCommand(dependencies = {}) {
+    const log = dependencies.log ?? console.log;
+    const cwd = dependencies.cwd ?? process.cwd();
+    const selectTemplate = dependencies.promptTemplate ?? promptTemplateName;
+    const askProjectName = dependencies.promptProjectName ?? promptProjectName;
+    const downloadTemplatesDirectory = dependencies.downloadTemplatesDirectory ?? downloadTemplatesDirectoryFromGithub;
+    const tempRootDir = await mkdtemp(path.join(os.tmpdir(), 'create-fugi-'));
+    try {
+        log('Fetching templates from GitHub...');
+        const { templatesRootDir } = await downloadTemplatesDirectory(tempRootDir);
+        const templates = await listTemplates(templatesRootDir);
+        if (templates.length === 0) {
+            throw new Error('No templates found in remote repository');
+        }
+        const selectedTemplateName = await selectTemplate(templates);
+        const selectedTemplate = templates.find((template) => template.name === selectedTemplateName);
+        if (selectedTemplate === undefined) {
+            throw new Error(`Template "${selectedTemplateName}" is not available.`);
+        }
+        const rawProjectName = await askProjectName();
+        const projectName = validateProjectName(rawProjectName);
+        const targetDir = path.resolve(cwd, projectName);
+        await ensureDirectoryDoesNotExist(targetDir);
+        await copyTemplate(selectedTemplate.absolutePath, targetDir);
+        log(`Project created at ${targetDir}`);
+        log(`Next steps:\n  cd ${projectName}`);
+    }
+    finally {
+        await rm(tempRootDir, { recursive: true, force: true });
+    }
+}

package/dist/index.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { pathToFileURL } from 'node:url';
+import { runCreateCommand } from './commands/create.js';
+export const HELP_TEXT = `Usage:
+  pnpm create fugi
+  create-fugi`;
+export async function runCli(argv, dependencies = {}) {
+    const command = argv[0];
+    if (command === undefined || command === 'create') {
+        await (dependencies.runCreateCommand ?? runCreateCommand)();
+        return 0;
+    }
+    ;
+    (dependencies.writeStdout ?? console.log)(HELP_TEXT);
+    return 1;
+}
+function formatError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+async function main() {
+    try {
+        const exitCode = await runCli(process.argv.slice(2));
+        process.exitCode = exitCode;
+    }
+    catch (error) {
+        console.error(formatError(error));
+        process.exitCode = 1;
+    }
+}
+const entry = process.argv[1];
+if (entry !== undefined && import.meta.url === pathToFileURL(entry).href) {
+    void main();
+}

package/dist/lib/github.js

@@ -0,0 +1,75 @@
+import { mkdir, readdir, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { x as extractArchive } from 'tar';
+const GITHUB_OWNER = 'ryougifujino';
+const GITHUB_REPO = 'create-fugi';
+const GITHUB_REPOSITORY_API = `https://api.github.com/repos/${GITHUB_OWNER}/${GITHUB_REPO}`;
+const GITHUB_USER_AGENT = 'create-fugi-cli';
+function assertOkResponse(response, requestUrl) {
+    if (!response.ok) {
+        throw new Error(`Request failed (${response.status} ${response.statusText}) for ${requestUrl}`);
+    }
+}
+export async function fetchDefaultBranch(fetchImpl = fetch) {
+    const response = await fetchImpl(GITHUB_REPOSITORY_API, {
+        headers: {
+            Accept: 'application/vnd.github+json',
+            'User-Agent': GITHUB_USER_AGENT,
+        },
+    });
+    assertOkResponse(response, GITHUB_REPOSITORY_API);
+    const responseJson = (await response.json());
+    const branch = responseJson?.default_branch;
+    if (typeof branch !== 'string' || branch.length === 0) {
+        throw new Error('Failed to resolve default branch from GitHub response.');
+    }
+    return branch;
+}
+export async function downloadTemplatesDirectory(tempRootDir, fetchImpl = fetch) {
+    const branch = await fetchDefaultBranch(fetchImpl);
+    const tarballUrl = `https://codeload.github.com/${GITHUB_OWNER}/${GITHUB_REPO}/tar.gz/refs/heads/${encodeURIComponent(branch)}`;
+    const tarballPath = path.join(tempRootDir, 'repository.tar.gz');
+    const extractDir = path.join(tempRootDir, 'extracted');
+    const tarballResponse = await fetchImpl(tarballUrl, {
+        headers: {
+            'User-Agent': GITHUB_USER_AGENT,
+        },
+    });
+    assertOkResponse(tarballResponse, tarballUrl);
+    const tarballBytes = Buffer.from(await tarballResponse.arrayBuffer());
+    await writeFile(tarballPath, tarballBytes);
+    await mkdir(extractDir, { recursive: true });
+    await extractArchive({
+        cwd: extractDir,
+        file: tarballPath,
+    });
+    const extractedRepositoryRootDir = await resolveExtractedRepositoryRootDir(extractDir);
+    const templatesRootDir = path.join(extractedRepositoryRootDir, 'templates');
+    await assertDirectoryExists(templatesRootDir, 'Remote repository does not contain a templates directory.');
+    return {
+        branch,
+        templatesRootDir,
+    };
+}
+async function resolveExtractedRepositoryRootDir(extractDir) {
+    const entries = await readdir(extractDir, { withFileTypes: true });
+    const directories = entries.filter((entry) => entry.isDirectory());
+    if (directories.length !== 1) {
+        throw new Error(`Expected one root directory in repository archive, but found ${directories.length}.`);
+    }
+    return path.join(extractDir, directories[0].name);
+}
+async function assertDirectoryExists(directoryPath, errorMessage) {
+    try {
+        const directoryStat = await stat(directoryPath);
+        if (!directoryStat.isDirectory()) {
+            throw new Error(errorMessage);
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(errorMessage, { cause: error });
+        }
+        throw error;
+    }
+}

package/dist/lib/templates.js

@@ -0,0 +1,51 @@
+import { cp, readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+const PROJECT_NAME_PATTERN = /^[A-Za-z0-9._-]+$/;
+export async function listTemplates(templatesRootDir) {
+    const entries = await readdir(templatesRootDir, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => ({
+        name: entry.name,
+        absolutePath: path.join(templatesRootDir, entry.name),
+    }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+export function validateProjectName(rawProjectName) {
+    const projectName = rawProjectName.trim();
+    if (projectName.length === 0) {
+        throw new Error('Project name is required.');
+    }
+    if (projectName === '.' || projectName === '..') {
+        throw new Error('Project name cannot be "." or "..".');
+    }
+    if (/[\\/]/.test(projectName)) {
+        throw new Error('Project name must be a single directory name.');
+    }
+    if (!PROJECT_NAME_PATTERN.test(projectName)) {
+        throw new Error('Project name can only contain letters, numbers, dots, underscores, and hyphens.');
+    }
+    if (path.basename(projectName) !== projectName) {
+        throw new Error('Project name must not include path traversal.');
+    }
+    return projectName;
+}
+export async function ensureDirectoryDoesNotExist(targetDir) {
+    try {
+        await stat(targetDir);
+        throw new Error(`Target directory already exists: ${targetDir}`);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return;
+        }
+        throw error;
+    }
+}
+export async function copyTemplate(templateDir, targetDir) {
+    await cp(templateDir, targetDir, {
+        recursive: true,
+        errorOnExist: true,
+        force: false,
+    });
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "create-fugi",
+  "version": "1.0.0",
+  "description": "",
+  "type": "module",
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "main": "dist/index.js",
+  "bin": {
+    "create-fugi": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "lint-staged": {
+    "src/**/*.{js,jsx,ts,tsx}": [
+      "eslint --max-warnings=0 --fix",
+      "prettier --write"
+    ],
+    "src/**/*.{json,md,html,yml,yaml}": [
+      "prettier --write"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com:ryougifujino/create-fugi.git"
+  },
+  "keywords": [],
+  "author": "ryougifujino",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ryougifujino/create-fugi/issues"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.0.1",
+    "tar": "^7.5.2"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^20.4.1",
+    "@commitlint/config-conventional": "^20.4.1",
+    "@eslint/js": "^10.0.1",
+    "@types/node": "24.10.12",
+    "@typescript/native-preview": "7.0.0-dev.20260208.1",
+    "eslint": "^10.0.0",
+    "eslint-config-prettier": "^10.1.8",
+    "globals": "^17.3.0",
+    "lefthook": "^2.1.0",
+    "lint-staged": "^16.2.7",
+    "prettier": "3.8.1",
+    "rimraf": "^6.1.2",
+    "typescript-eslint": "^8.54.0"
+  },
+  "scripts": {
+    "typecheck": "tsgo --noEmit",
+    "build": "rimraf dist && tsgo",
+    "test": "pnpm typecheck && node --test \"test/**/*.test.ts\""
+  }
+}