create-gtkx 2.0.0-beta.10 → 2.0.0-beta.11

package/src/command.ts

@@ -1,50 +1,99 @@
 import * as p from "@clack/prompts";
 import { assertSupportedNodeVersion } from "@gtkx/config/internal";
-import { errorMessage } from "@gtkx/utils";
-import { defineCommand } from "citty";
+import { camelCase, errorMessage, kebabCase } from "@gtkx/utils";
+import { type ArgsDef, defineCommand, type ParsedArgs } from "citty";
 import { parseArgs, type ParseArgsOptionsConfig } from "node:util";
 import { OperationCanceledError, ScaffoldAbortedError } from "./errors.js";
 import { PACKAGE_MANAGER_FLAG_DESCRIPTION } from "./package-managers.js";
 import { scaffold } from "./scaffolder.js";
 
-type CreateCommandArgs = {
-    name?: string | undefined;
-    "application-id"?: string | undefined;
-    "display-name"?: string | undefined;
-    "package-manager"?: string | undefined;
-    typescript?: boolean | undefined;
-    vitest?: boolean | undefined;
-    yes?: boolean | undefined;
-    "no-interactive"?: boolean | undefined;
-    overwrite?: boolean | undefined;
-    "skip-install"?: boolean | undefined;
-};
+const CREATE_ARGS = {
+    name: {
+        type: "positional",
+        description: "Target directory or project name (e.g. my-app, ., apps/my-app)",
+        required: false,
+    },
+    "application-id": {
+        type: "string",
+        description: "Application ID (e.g., com.example.myapp)",
+    },
+    "display-name": {
+        type: "string",
+        description: "Application display name (e.g., My App)",
+    },
+    "package-manager": {
+        type: "string",
+        alias: "p",
+        description: PACKAGE_MANAGER_FLAG_DESCRIPTION,
+    },
+    typescript: {
+        type: "boolean",
+        negativeDescription: "Scaffold the application in JavaScript instead of TypeScript",
+        description: "Scaffold the application in TypeScript",
+    },
+    vitest: {
+        type: "boolean",
+        description: "Include a Vitest testing setup",
+    },
+    yes: {
+        type: "boolean",
+        alias: "y",
+        description: "Skip prompts and accept defaults for unspecified options",
+    },
+    interactive: {
+        type: "boolean",
+        description: "Prompt for unspecified options when running in a terminal",
+        negativeDescription:
+            "Run without prompts, using the default for every option not passed on the command line " +
+            "(same as --yes)",
+    },
+    overwrite: {
+        type: "boolean",
+        alias: "f",
+        description: "Replace scaffold files in a non-empty target directory when running without prompts",
+    },
+    "skip-install": {
+        type: "boolean",
+        description: "Create the project without installing dependencies",
+    },
+} as const satisfies ArgsDef;
+
+type OptionToken = Extract<
+    ReturnType<typeof parseArgs<{ tokens: true; strict: false }>>["tokens"][number],
+    { kind: "option" }
+>;
+
+type CreateCommandArgs = Pick<ParsedArgs<typeof CREATE_ARGS>, keyof typeof CREATE_ARGS>;
+type CreateOption = Exclude<(typeof CREATE_ARGS)[keyof typeof CREATE_ARGS], { type: "positional" }>;
 
-const STRICT_OPTIONS: ParseArgsOptionsConfig = {
-    "application-id": { type: "string" },
-    applicationId: { type: "string" },
-    "display-name": { type: "string" },
-    displayName: { type: "string" },
-    "package-manager": { type: "string", short: "p" },
-    packageManager: { type: "string" },
-    typescript: { type: "boolean" },
-    vitest: { type: "boolean" },
-    yes: { type: "boolean", short: "y" },
-    "no-interactive": { type: "boolean" },
-    noInteractive: { type: "boolean" },
-    overwrite: { type: "boolean", short: "f" },
-    "skip-install": { type: "boolean" },
-    skipInstall: { type: "boolean" },
+const strictOption = (definition: CreateOption): ParseArgsOptionsConfig[string] => ({
+    type: definition.type,
+    ...("alias" in definition && { short: definition.alias }),
+});
+
+const createStrictOptions = (): ParseArgsOptionsConfig => {
+    const options: ParseArgsOptionsConfig = {};
+
+    for (const [name, definition] of Object.entries(CREATE_ARGS)) {
+        if (definition.type === "positional") {
+            continue;
+        }
+
+        options[name] = strictOption(definition);
+
+        if (camelCase(name) !== name) {
+            options[camelCase(name)] = { type: definition.type };
+        }
+    }
+
+    return options;
 };
 
-const BOOLEAN_OPTIONS: ReadonlySet<string> = new Set([
-    "--typescript",
-    "--vitest",
-    "--yes",
-    "--overwrite",
-    "--skip-install",
-    "--skipInstall",
-]);
+const STRICT_OPTIONS = createStrictOptions();
+
+const BOOLEAN_OPTIONS = new Set(
+    Object.entries(STRICT_OPTIONS).filter(([, option]) => option.type === "boolean").map(([name]) => `--${name}`),
+);
 
 const normalizeBooleanArgument = (argument: string): string => {
     const [option, value, ...rest] = argument.split("=");
@@ -60,89 +109,40 @@ const normalizeBooleanArgument = (argument: string): string => {
     return value === "false" ? `--no-${option.slice(2)}` : argument;
 };
 
-const isKnownOption = (name: string, rawName: string): boolean =>
-    Object.hasOwn(STRICT_OPTIONS, name) || Object.hasOwn(STRICT_OPTIONS, rawName.replace(/^--/, ""));
+const canonicalOption = (token: OptionToken): [string, string | boolean] =>
+    [kebabCase(token.name), token.value ?? !token.rawName.startsWith("--no-")];
 
-const unknownOptions = (args: string[]): string[] => {
-    const { tokens } = parseArgs({
-        args,
+/* TODO: Keep ordered token parsing until Citty respects the order of positive and negated flags.
+ * https://github.com/gtkx-org/gtkx/issues/732
+ */
+const parseCreateArguments = (rawArgs: string[]): CreateCommandArgs => {
+    const { tokens, positionals } = parseArgs({
+        args: rawArgs.map((argument) =>
+            normalizeBooleanArgument(argument === "--noInteractive" ? "--no-interactive" : argument)),
         options: STRICT_OPTIONS,
         allowPositionals: true,
         allowNegative: true,
-        strict: false,
+        strict: true,
         tokens: true,
     });
 
-    return tokens.flatMap((token) =>
-        token.kind === "option" && !isKnownOption(token.name, token.rawName) ? [token.rawName] : []);
-};
-
-const assertKnownArguments = (rawArgs: string[]): void => {
-    const args = rawArgs.map((argument) => normalizeBooleanArgument(argument));
-    const [unknown] = unknownOptions(args);
-
-    if (unknown !== undefined) {
-        throw new Error(`Unknown option "${unknown}". Pass --help to list the supported options`);
+    if (positionals.length > 1) {
+        throw new TypeError("Expected one project directory");
     }
 
-    parseArgs({ args, options: STRICT_OPTIONS, allowPositionals: true, allowNegative: true, strict: true });
+    return {
+        ...Object.fromEntries(tokens.filter((token) => token.kind === "option").map((token) => canonicalOption(token))),
+        name: positionals[0],
+    } as CreateCommandArgs;
 };
 
 const scaffoldCommand = defineCommand({
     meta: {
         name: "create",
-        description: "Create a new Adwaita-first GNOME application with GTKX",
-    },
-    args: {
-        name: {
-            type: "positional",
-            description: "Target directory or project name (e.g. my-app, ., apps/my-app)",
-            required: false,
-        },
-        "application-id": {
-            type: "string",
-            description: "Application ID (e.g., com.example.myapp)",
-        },
-        "display-name": {
-            type: "string",
-            description: "Application display name (e.g., My App)",
-        },
-        "package-manager": {
-            type: "string",
-            alias: "p",
-            description: PACKAGE_MANAGER_FLAG_DESCRIPTION,
-        },
-        typescript: {
-            type: "boolean",
-            negativeDescription: "Scaffold the application in JavaScript instead of TypeScript",
-            description: "Scaffold the application in TypeScript",
-        },
-        vitest: {
-            type: "boolean",
-            description: "Include a Vitest testing setup",
-        },
-        yes: {
-            type: "boolean",
-            alias: "y",
-            description: "Skip prompts and accept defaults for unspecified options",
-        },
-        "no-interactive": {
-            type: "boolean",
-            description:
-                "Run without prompts, using the default for every option not passed on the command line " +
-                "(same as --yes)",
-        },
-        overwrite: {
-            type: "boolean",
-            alias: "f",
-            description: "Replace scaffold files in a non-empty target directory when running without prompts",
-        },
-        "skip-install": {
-            type: "boolean",
-            description: "Create the project without installing dependencies",
-        },
+        description: "Create a Linux application with GTKX",
     },
-    run: ({ args, rawArgs }) => runCreate(args, rawArgs),
+    args: CREATE_ARGS,
+    run: ({ rawArgs }) => runCreate(rawArgs),
 });
 
 const settleScaffoldFailure = (error: unknown): void => {
@@ -157,11 +157,10 @@ const settleScaffoldFailure = (error: unknown): void => {
     process.exitCode = 1;
 };
 
-const runCreate = async (args: CreateCommandArgs, rawArgs: string[]): Promise<void> => {
-    const isInteractive = args["no-interactive"] || args.yes ? false : process.stdin.isTTY;
-
+const runCreate = async (rawArgs: string[]): Promise<void> => {
     try {
-        assertKnownArguments(rawArgs);
+        const args = parseCreateArguments(rawArgs);
+        const isInteractive = args.interactive !== false && !args.yes && process.stdin.isTTY;
         assertSupportedNodeVersion();
         await scaffold({
             name: args.name,

package/src/manifest.ts

@@ -1,5 +1,4 @@
-import { randomUUID } from "node:crypto";
-import { readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
 const PACKAGE_JSON_FILE = "package.json";
@@ -8,14 +7,7 @@ const updateManifest = (root: string, mutate: (manifest: Record<string, unknown>
     const manifestPath = join(root, PACKAGE_JSON_FILE);
     const manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as Record<string, unknown>;
     mutate(manifest);
-    const pendingPath = join(root, `.package-${randomUUID()}.json`);
-
-    try {
-        writeFileSync(pendingPath, `${JSON.stringify(manifest, null, 4)}\n`, { flag: "wx", mode: 0o600 });
-        renameSync(pendingPath, manifestPath);
-    } finally {
-        rmSync(pendingPath, { force: true });
-    }
+    writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 4)}\n`);
 };
 
 export { updateManifest };

package/src/package-managers.ts

@@ -5,7 +5,6 @@ const PACKAGE_MANAGERS = [
         value: "pnpm",
         label: "pnpm",
         devCommand: "pnpm dev",
-        addCommand: "pnpm add",
         installCommand: "pnpm install",
         isRecommended: true,
     },
@@ -13,7 +12,6 @@ const PACKAGE_MANAGERS = [
         value: "npm",
         label: "npm",
         devCommand: "npm run dev",
-        addCommand: "npm install",
         installCommand: "npm install",
         isRecommended: false,
     },
@@ -21,7 +19,6 @@ const PACKAGE_MANAGERS = [
         value: "yarn",
         label: "yarn",
         devCommand: "yarn dev",
-        addCommand: "yarn add",
         installCommand: "yarn install",
         isRecommended: false,
     },