create-riebeckite 0.0.14 → 0.0.16

package/README.md

@@ -6,6 +6,15 @@ Create a new Riebeckite site from an official starter preset.
 
 ## Usage
 
+Interactive (recommended): run without arguments and answer the prompts for
+the project name, preset, content source, and deployment.
+
+```sh
+npx create-riebeckite
+```
+
+Passing any argument keeps the command non-interactive:
+
 ```sh
 npx create-riebeckite my-site
 cd my-site
@@ -13,6 +22,23 @@ npm install
 npm exec riebeckite build
 ```
 
+## Choices
+
+The prompts ask, in order:
+
+| Prompt | Options | Recommendation |
+| --- | --- | --- |
+| Project name | the folder to create (empty input uses the default name) | any name, e.g. `my-site` |
+| Preset | `starter`, `minimal`, `showcase`, `empty` | `starter` for most sites |
+| Content source | `This project`, `Separate GitHub repository` | `This project` to start |
+| Deployment | `GitHub Actions + Cloudflare Workers`, `Not now` | `Not now` for local development |
+
+`Separate GitHub repository` also asks for the content and site repositories,
+and GitHub Actions deployment is then configured for you. That setup is covered
+in the [content repository guide](../../docs/en/docs/guides/content-repositories.md).
+Deployment can be added later, described in
+[Deployment](../../docs/en/docs/getting-started/deployment.md).
+
 ## Options
 
 | Option | Description |
@@ -31,6 +57,8 @@ For example, scaffold the complete feature tour:
 npx create-riebeckite my-site --preset showcase
 ```
 
+## External content repository
+
 To use a separate content repository and deploy after its `main` branch is
 pushed, generate the common workflow once (the preset does not affect it):
 

package/README_ja.md

@@ -7,6 +7,15 @@ CLI ツールです。
 
 ## 使い方
 
+対話モード（推奨）: 引数なしで実行すると、プロジェクト名・preset・
+コンテンツの格納場所・デプロイについて順に確認します。
+
+```sh
+npx create-riebeckite
+```
+
+引数を 1 つでも渡すと、従来どおり非対話で動作します。
+
 ```sh
 npx create-riebeckite my-site
 cd my-site
@@ -14,6 +23,19 @@ npm install
 npm exec riebeckite build
 ```
 
+## Choices
+
+対話式の CLI は、次の順に確認します。
+
+| 質問 | 選択肢 | 推奨 |
+| --- | --- | --- |
+| Project name | 作るフォルダ名（空なら既定の名前） | 任意。例: `my-site` |
+| Preset | `starter`、`minimal`、`showcase`、`empty` | 大半のサイトは `starter` |
+| Content source | `This project`、`Separate GitHub repository` | 最初は `This project` |
+| デプロイ設定 | `GitHub Actions + Cloudflare Workers`、`Not now` | 手元で試すなら `Not now` |
+
+`Separate GitHub repository` を選ぶと content と site のリポジトリ名も入力し、GitHub Actions のデプロイ設定が自動で構成されます。この構成は[content repository ガイド](../../docs/ja/docs/guides/content-repositories.md)に、デプロイの追加方法は [Deployment](../../docs/ja/docs/getting-started/deployment.md) にあります。
+
 ## オプション
 
 | オプション | 説明 |
@@ -32,6 +54,8 @@ npm exec riebeckite build
 npx create-riebeckite my-site --preset showcase
 ```
 
+## External content repository
+
 別の記事リポジトリを使い、その `main` への push でデプロイする場合は、共通の
 workflow を一度だけ生成します。preset による違いはありません。
 
@@ -63,7 +87,7 @@ npx create-riebeckite --list-presets
 | --- | --- |
 | `starter` | 大半のサイトにおすすめ |
 | `minimal` | 最小限の設定で作る Markdown サイト |
-| `showcase` | 描画例とローカルのフィクスチャで Riebeckite の機能と Plugin を確認する構成 |
+| `showcase` | 描画例とローカルの fixture で Riebeckite の機能と Plugin を確認する構成 |
 | `empty` | 独自構成のための空のシェル |
 
 各 preset の説明は次のとおりです（`--list-presets` で表示される内容と同じです）。

package/dist/src/arguments.d.ts

@@ -0,0 +1,13 @@
+import { type ScaffoldPresetName } from "@riebeckite/honox";
+export type CreateRiebeckiteOptions = {
+    readonly directory: string;
+    readonly force: boolean;
+    readonly preset: ScaffoldPresetName;
+    readonly listPresets: boolean;
+    readonly githubActions: boolean;
+    readonly cloudflareWorkers: boolean;
+    readonly contentRepository?: string;
+    readonly siteRepository?: string;
+};
+export declare function parseArguments(arguments_: readonly string[]): CreateRiebeckiteOptions;
+export declare function printPresets(): void;

package/dist/src/index.d.ts

@@ -1,11 +1,2 @@
-import { type ScaffoldPresetName } from "@riebeckite/honox";
-export type CreateRiebeckiteOptions = {
-    readonly directory: string;
-    readonly force: boolean;
-    readonly preset: ScaffoldPresetName;
-    readonly listPresets: boolean;
-    readonly githubActions: boolean;
-    readonly contentRepository?: string;
-    readonly siteRepository?: string;
-};
+export type { CreateRiebeckiteOptions } from "./arguments.js";
 export declare function runCreateRiebeckite(arguments_: readonly string[]): Promise<void>;

package/dist/src/index.js

@@ -2,54 +2,16 @@
 import path from "node:path";
 import {
   formatScaffoldNextSteps,
-  isScaffoldPresetName,
-  SCAFFOLD_PRESET_NAMES,
   ScaffoldSiteError,
-  scaffoldPresets,
   scaffoldRiebeckiteSite
 } from "@riebeckite/honox";
-async function runCreateRiebeckite(arguments_) {
-  let options;
-  try {
-    options = parseArguments(arguments_);
-  } catch (error) {
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exitCode = 1;
-    return;
-  }
-  if (options.listPresets) {
-    printPresets();
-    return;
-  }
-  const targetDirectory = path.resolve(process.cwd(), options.directory);
-  try {
-    const result = await scaffoldRiebeckiteSite({
-      targetDirectory,
-      overwrite: options.force,
-      preset: options.preset,
-      githubActions: options.githubActions,
-      contentRepository: options.contentRepository,
-      siteRepository: options.siteRepository
-    });
-    const relative = path.relative(process.cwd(), result.targetDirectory) || ".";
-    console.log(`Created a ${options.preset} Riebeckite site in ${relative}`);
-    console.log("");
-    console.log(formatScaffoldNextSteps(relative));
-    if (options.contentRepository !== void 0) {
-      console.log("");
-      console.log(
-        "Copy github/notify-site.yml to the content repository as .github/workflows/notify-site.yml."
-      );
-    }
-  } catch (error) {
-    if (error instanceof ScaffoldSiteError) {
-      console.error(error.message);
-      process.exitCode = 1;
-      return;
-    }
-    throw error;
-  }
-}
+
+// src/arguments.ts
+import {
+  isScaffoldPresetName,
+  SCAFFOLD_PRESET_NAMES,
+  scaffoldPresets
+} from "@riebeckite/honox";
 function parseArguments(arguments_) {
   let directory;
   let force = false;
@@ -109,6 +71,7 @@ function parseArguments(arguments_) {
     preset: preset ?? "starter",
     listPresets,
     githubActions,
+    cloudflareWorkers: false,
     contentRepository,
     siteRepository
   };
@@ -120,6 +83,316 @@ function printPresets() {
     console.log(`  ${name}: ${scaffoldPresets[name].description}`);
   }
 }
+
+// src/interactive.ts
+import { isCancel, log, select, text } from "@clack/prompts";
+import {
+  SCAFFOLD_PRESET_NAMES as SCAFFOLD_PRESET_NAMES2,
+  scaffoldPresets as scaffoldPresets2
+} from "@riebeckite/honox";
+var DEFAULT_DIRECTORY = "my-riebeckite-site";
+var DEFAULT_INTERACTIVE_DEPLOYMENT = "none";
+function interactiveAnswersToOptions(answers) {
+  const external = answers.contentSource === "external";
+  return {
+    directory: answers.directory,
+    force: false,
+    preset: answers.preset,
+    listPresets: false,
+    githubActions: external || answers.deployment === "github-actions",
+    cloudflareWorkers: !external && answers.deployment === "cloudflare",
+    contentRepository: external ? answers.contentRepository : void 0,
+    siteRepository: external ? answers.siteRepository : void 0
+  };
+}
+async function promptInteractiveAnswers() {
+  const projectInput = await text({
+    message: "Project name",
+    placeholder: DEFAULT_DIRECTORY,
+    defaultValue: DEFAULT_DIRECTORY
+  });
+  if (isCancel(projectInput)) return null;
+  const directory = projectInput.trim() || DEFAULT_DIRECTORY;
+  const preset = await select({
+    message: "Choose a preset",
+    initialValue: "starter",
+    options: SCAFFOLD_PRESET_NAMES2.map((name) => ({
+      value: name,
+      label: capitalize(name),
+      hint: scaffoldPresets2[name].description
+    }))
+  });
+  if (isCancel(preset)) return null;
+  const contentSource = await select({
+    message: "Where will you write content?",
+    initialValue: "local",
+    options: [
+      { value: "local", label: "This project" },
+      { value: "external", label: "Separate GitHub repository" }
+    ]
+  });
+  if (isCancel(contentSource)) return null;
+  let answers;
+  if (contentSource === "external") {
+    log.info(
+      "Separate repositories use GitHub Actions so content updates can trigger site deployments."
+    );
+    const contentRepository = await text({
+      message: "Content repository",
+      placeholder: "OWNER/notes"
+    });
+    if (isCancel(contentRepository)) return null;
+    const siteRepository = await text({
+      message: "Site repository",
+      placeholder: "OWNER/site"
+    });
+    if (isCancel(siteRepository)) return null;
+    answers = {
+      directory,
+      preset,
+      contentSource,
+      deployment: "github-actions",
+      contentRepository: contentRepository.trim(),
+      siteRepository: siteRepository.trim()
+    };
+  } else {
+    const deployment = await select({
+      message: "Set up deployment?",
+      initialValue: DEFAULT_INTERACTIVE_DEPLOYMENT,
+      options: [
+        {
+          value: "cloudflare",
+          label: "Cloudflare Workers",
+          hint: "Publish from this machine"
+        },
+        {
+          value: "github-actions",
+          label: "GitHub Actions",
+          hint: "Deploy on every push"
+        },
+        { value: "none", label: "Not now" }
+      ]
+    });
+    if (isCancel(deployment)) return null;
+    answers = { directory, preset, contentSource, deployment };
+  }
+  log.step("Creating Riebeckite site...");
+  return answers;
+}
+async function promptDeployNow() {
+  const answer = await select({
+    message: "Deploy now?",
+    initialValue: "yes",
+    options: [
+      { value: "yes", label: "Yes" },
+      { value: "later", label: "Later" }
+    ]
+  });
+  if (isCancel(answer)) return false;
+  return answer === "yes";
+}
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+// src/package-manager.ts
+import { PACKAGE_MANAGER } from "@riebeckite/honox";
+function packageManagerCommands(name = PACKAGE_MANAGER) {
+  if (name === "pnpm") {
+    return {
+      name,
+      install: { command: "pnpm", args: ["install"], label: "pnpm install" },
+      build: { command: "pnpm", args: ["build"], label: "pnpm build" },
+      deploy: {
+        command: "pnpm",
+        args: ["exec", "riebeckite", "deploy"],
+        label: "pnpm exec riebeckite deploy"
+      }
+    };
+  }
+  return {
+    name: "npm",
+    install: { command: "npm", args: ["install"], label: "npm install" },
+    build: { command: "npm", args: ["run", "build"], label: "npm run build" },
+    deploy: {
+      command: "npm",
+      args: ["exec", "riebeckite", "deploy"],
+      label: "npm exec riebeckite deploy"
+    }
+  };
+}
+
+// src/publish.ts
+var DeploymentFailure = class extends Error {
+  phase;
+  constructor(phase, message) {
+    super(message);
+    this.name = "DeploymentFailure";
+    this.phase = phase;
+  }
+};
+async function installDependencies(directory, commands, run) {
+  await runCommand("install", commands.install, directory, run);
+}
+async function buildAndDeploy(directory, commands, run) {
+  await runCommand("build", commands.build, directory, run);
+  await runCommand("deploy", commands.deploy, directory, run);
+}
+function formatCloudflareNextSteps(relativeDirectory, commands) {
+  const lines = ["Next steps:"];
+  if (relativeDirectory !== ".") {
+    lines.push(`  cd ${relativeDirectory}`);
+  }
+  lines.push(`  ${commands.build.label}`);
+  lines.push(`  ${commands.deploy.label}`);
+  return lines.join("\n");
+}
+function formatDeploymentFailure(relativeDirectory, commands, failure) {
+  const lines = [
+    "Project created successfully.",
+    deploymentFailureSummary(failure.phase),
+    failure.message,
+    "You can retry with:"
+  ];
+  if (relativeDirectory !== ".") {
+    lines.push(`  cd ${relativeDirectory}`);
+  }
+  if (failure.phase === "install") {
+    lines.push(`  ${commands.install.label}`);
+  }
+  lines.push(`  ${commands.build.label}`);
+  lines.push(`  ${commands.deploy.label}`);
+  return lines.join("\n");
+}
+function deploymentFailureSummary(phase) {
+  if (phase === "install") return "Installing dependencies failed.";
+  if (phase === "build") return "Build failed.";
+  return "Deployment failed.";
+}
+async function runCommand(phase, command, directory, run) {
+  let exitCode;
+  try {
+    exitCode = await run(command.command, command.args, directory);
+  } catch (error) {
+    throw new DeploymentFailure(
+      phase,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  if (exitCode !== 0) {
+    throw new DeploymentFailure(
+      phase,
+      `${command.label} exited with code ${exitCode}.`
+    );
+  }
+}
+
+// src/run-commands.ts
+import { spawn } from "node:child_process";
+function spawnCommand(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, [...args], {
+      cwd,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => resolve(code ?? 1));
+  });
+}
+
+// src/index.ts
+async function runCreateRiebeckite(arguments_) {
+  const resolved = await resolveOptions(arguments_);
+  if (resolved === null) return;
+  const { options, interactive } = resolved;
+  if (options.listPresets) {
+    printPresets();
+    return;
+  }
+  const targetDirectory = path.resolve(process.cwd(), options.directory);
+  let result;
+  try {
+    result = await scaffoldRiebeckiteSite({
+      targetDirectory,
+      overwrite: options.force,
+      preset: options.preset,
+      githubActions: options.githubActions,
+      cloudflareWorkers: options.cloudflareWorkers,
+      contentRepository: options.contentRepository,
+      siteRepository: options.siteRepository
+    });
+  } catch (error) {
+    if (error instanceof ScaffoldSiteError) {
+      console.error(error.message);
+      process.exitCode = 1;
+      return;
+    }
+    throw error;
+  }
+  const relative = path.relative(process.cwd(), result.targetDirectory) || ".";
+  console.log(`Created a ${options.preset} Riebeckite site in ${relative}`);
+  console.log("");
+  if (interactive && options.cloudflareWorkers) {
+    await publishCloudflareSite(targetDirectory, relative);
+    return;
+  }
+  printScaffoldNextSteps(options, result, relative);
+}
+async function resolveOptions(arguments_) {
+  if (arguments_.length === 0) {
+    const answers = await promptInteractiveAnswers();
+    if (answers === null) {
+      console.log("Operation cancelled.");
+      return null;
+    }
+    return { options: interactiveAnswersToOptions(answers), interactive: true };
+  }
+  try {
+    return { options: parseArguments(arguments_), interactive: false };
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+    return null;
+  }
+}
+function printScaffoldNextSteps(options, result, relative) {
+  const externalContent = options.contentRepository !== void 0;
+  const editFile = !externalContent && result.files.includes("content/index.md") ? "content/index.md" : void 0;
+  console.log(formatScaffoldNextSteps(relative, { editFile, externalContent }));
+}
+async function publishCloudflareSite(targetDirectory, relative) {
+  const commands = packageManagerCommands();
+  console.log(`Installing dependencies with ${commands.name}...`);
+  try {
+    await installDependencies(targetDirectory, commands, spawnCommand);
+  } catch (error) {
+    if (!(error instanceof DeploymentFailure)) throw error;
+    reportDeploymentFailure(error, relative);
+    return;
+  }
+  const deployNow = await promptDeployNow();
+  if (!deployNow) {
+    console.log("");
+    console.log(formatCloudflareNextSteps(relative, commands));
+    return;
+  }
+  try {
+    await buildAndDeploy(targetDirectory, commands, spawnCommand);
+  } catch (error) {
+    if (!(error instanceof DeploymentFailure)) throw error;
+    reportDeploymentFailure(error, relative);
+    return;
+  }
+  console.log("");
+  console.log("Deployment complete.");
+}
+function reportDeploymentFailure(error, relative) {
+  const commands = packageManagerCommands();
+  console.error("");
+  console.error(formatDeploymentFailure(relative, commands, error));
+  process.exitCode = 1;
+}
 export {
   runCreateRiebeckite
 };

package/dist/src/interactive.d.ts

@@ -0,0 +1,26 @@
+import { type ScaffoldPresetName } from "@riebeckite/honox";
+import type { CreateRiebeckiteOptions } from "./arguments.js";
+export declare const DEFAULT_INTERACTIVE_DEPLOYMENT: InteractiveDeployment;
+export type InteractiveContentSource = "local" | "external";
+export type InteractiveDeployment = "cloudflare" | "github-actions" | "none";
+export type InteractiveAnswers = {
+    readonly directory: string;
+    readonly preset: ScaffoldPresetName;
+    readonly contentSource: InteractiveContentSource;
+    readonly deployment: InteractiveDeployment;
+    readonly contentRepository?: string;
+    readonly siteRepository?: string;
+};
+/**
+ * Map interactive answers onto the same options object the non-interactive
+ * flags produce. A separate content repository always deploys through GitHub
+ * Actions, so the answered deployment never wins in that combination.
+ */
+export declare function interactiveAnswersToOptions(answers: InteractiveAnswers): CreateRiebeckiteOptions;
+/**
+ * Run the prompt flow. Returns `null` when the user cancels, so the caller can
+ * exit without a stack trace. Repository values are only trimmed here; their
+ * `owner/repository` shape is validated by the existing scaffold.
+ */
+export declare function promptInteractiveAnswers(): Promise<InteractiveAnswers | null>;
+export declare function promptDeployNow(): Promise<boolean>;

package/dist/src/package-manager.d.ts

@@ -0,0 +1,13 @@
+export type PackageManagerName = "npm" | "pnpm";
+export type PackageManagerCommand = {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly label: string;
+};
+export type PackageManagerCommands = {
+    readonly name: PackageManagerName;
+    readonly install: PackageManagerCommand;
+    readonly build: PackageManagerCommand;
+    readonly deploy: PackageManagerCommand;
+};
+export declare function packageManagerCommands(name?: PackageManagerName): PackageManagerCommands;

package/dist/src/publish.d.ts

@@ -0,0 +1,11 @@
+import type { PackageManagerCommands } from "./package-manager.js";
+import type { CommandRunner } from "./run-commands.js";
+export type DeploymentPhase = "install" | "build" | "deploy";
+export declare class DeploymentFailure extends Error {
+    readonly phase: DeploymentPhase;
+    constructor(phase: DeploymentPhase, message: string);
+}
+export declare function installDependencies(directory: string, commands: PackageManagerCommands, run: CommandRunner): Promise<void>;
+export declare function buildAndDeploy(directory: string, commands: PackageManagerCommands, run: CommandRunner): Promise<void>;
+export declare function formatCloudflareNextSteps(relativeDirectory: string, commands: PackageManagerCommands): string;
+export declare function formatDeploymentFailure(relativeDirectory: string, commands: PackageManagerCommands, failure: DeploymentFailure): string;

package/dist/src/run-commands.d.ts

@@ -0,0 +1,2 @@
+export type CommandRunner = (command: string, args: readonly string[], cwd: string) => Promise<number>;
+export declare function spawnCommand(command: string, args: readonly string[], cwd: string): Promise<number>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-riebeckite",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/src/index.js",
@@ -27,7 +27,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@riebeckite/honox": "0.0.14"
+    "@clack/prompts": "^1.8.1",
+    "@riebeckite/honox": "0.0.16"
   },
   "repository": {
     "type": "git",
@@ -50,6 +51,7 @@
   },
   "sideEffects": false,
   "scripts": {
-    "build": "node ../../scripts/build_package.mjs"
+    "build": "node ../../scripts/build_package.mjs",
+    "test": "node --import tsx --test \"test/*.test.ts\""
   }
 }