@beignet/cli 0.0.3 → 0.0.4

package/src/create-prompts.ts

@@ -0,0 +1,182 @@
+/**
+ * Interactive selection flow for `beignet create`.
+ *
+ * The decision helper is pure so the TTY gating stays unit-testable, and
+ * `@clack/prompts` is loaded lazily inside the prompt flow so non-interactive
+ * runs and CLI startup never pay for it.
+ */
+
+import {
+  type FeatureName,
+  featureChoices,
+  type IntegrationName,
+  integrationChoices,
+  type PackageManager,
+  type PresetName,
+  packageManagerChoices,
+  presetIntegrationDefaults,
+} from "./choices.js";
+
+/**
+ * Selections shared by create flags and interactive prompt answers.
+ */
+export type CreateSelections = {
+  directory?: string;
+  preset?: PresetName;
+  features?: readonly FeatureName[];
+  integrations?: readonly IntegrationName[];
+  packageManager?: PackageManager;
+};
+
+type CreatePromptFlags = CreateSelections & {
+  yes?: boolean;
+};
+
+type CreatePromptTty = {
+  stdin: boolean;
+  stdout: boolean;
+};
+
+/**
+ * Decide whether `beignet create` should run the interactive prompt flow.
+ *
+ * Prompts run only on a full TTY, only when `--yes` is absent, and only when
+ * no selection flag was passed. Any explicit preset, feature, integration, or
+ * package manager selection means the invocation is scripted, so the
+ * non-interactive path stays byte-identical for agents and CI.
+ */
+export function shouldPromptInteractively(
+  flags: CreatePromptFlags,
+  tty: CreatePromptTty,
+): boolean {
+  if (!tty.stdin || !tty.stdout) return false;
+  if (flags.yes) return false;
+
+  const selectionFlagPassed =
+    flags.preset !== undefined ||
+    (flags.features?.length ?? 0) > 0 ||
+    (flags.integrations?.length ?? 0) > 0 ||
+    flags.packageManager !== undefined;
+
+  return !selectionFlagPassed;
+}
+
+const featureHints: Record<FeatureName, string> = {
+  client: "Typed Beignet HTTP client",
+  "react-query": "TanStack Query helpers for contracts",
+  forms: "React Hook Form wired to contract bodies",
+  openapi: "OpenAPI document route generated from contracts",
+};
+
+const integrationHints: Record<IntegrationName, string> = {
+  "better-auth": "Better Auth routes and auth provider wiring",
+  "drizzle-turso": "Drizzle/libSQL persistence with Turso-ready config",
+  inngest: "Inngest-backed background jobs",
+  pino: "Pino logger provider",
+  resend: "Resend-backed mail provider",
+  "upstash-rate-limit": "Upstash-backed rate limiting",
+};
+
+/**
+ * Run the interactive `beignet create` prompt flow.
+ *
+ * Returns the completed selections, or undefined when the user cancels.
+ */
+export async function promptCreateSelections(
+  initial: CreateSelections,
+): Promise<CreateSelections | undefined> {
+  const prompts = await import("@clack/prompts");
+
+  prompts.intro("beignet create");
+
+  let directory = initial.directory;
+  if (directory === undefined) {
+    const answer = await prompts.text({
+      message: "Where should the app be created?",
+      placeholder: "my-app",
+      validate: (value) =>
+        value === undefined || value.trim() === ""
+          ? "Enter a project directory."
+          : undefined,
+    });
+    if (prompts.isCancel(answer)) return undefined;
+    directory = answer;
+  }
+
+  const preset = await prompts.select<PresetName>({
+    message: "Which starter preset?",
+    options: [
+      {
+        value: "standard",
+        label: "standard",
+        hint: "Full app layout with auth, database, jobs, and devtools",
+      },
+      {
+        value: "minimal",
+        label: "minimal",
+        hint: "Smallest contract/server/use-case loop",
+      },
+    ],
+    initialValue: "standard",
+  });
+  if (prompts.isCancel(preset)) return undefined;
+
+  // The standard preset already includes every starter feature, so the
+  // feature multiselect only appears when the preset leaves features open.
+  let features: readonly FeatureName[] | undefined;
+  if (preset === "minimal") {
+    const answer = await prompts.multiselect<FeatureName>({
+      message: "Add starter features? (press enter to skip)",
+      options: featureChoices.map((feature) => ({
+        value: feature,
+        label: feature,
+        hint: featureHints[feature],
+      })),
+      required: false,
+    });
+    if (prompts.isCancel(answer)) return undefined;
+    features = answer;
+  }
+
+  const presetIntegrations = new Set(presetIntegrationDefaults[preset]);
+  const integrationOptions = integrationChoices.filter(
+    (integration) => !presetIntegrations.has(integration),
+  );
+  let integrations: readonly IntegrationName[] | undefined;
+  if (integrationOptions.length > 0) {
+    const answer = await prompts.multiselect<IntegrationName>({
+      message:
+        presetIntegrations.size > 0
+          ? "Add provider integrations beyond the preset defaults? (press enter to skip)"
+          : "Add provider integrations? (press enter to skip)",
+      options: integrationOptions.map((integration) => ({
+        value: integration,
+        label: integration,
+        hint: integrationHints[integration],
+      })),
+      required: false,
+    });
+    if (prompts.isCancel(answer)) return undefined;
+    integrations = answer;
+  }
+
+  const packageManager = await prompts.select<PackageManager>({
+    message: "Which package manager?",
+    options: packageManagerChoices.map((manager) => ({
+      value: manager,
+      label: manager,
+    })),
+    initialValue: "bun",
+  });
+  if (prompts.isCancel(packageManager)) return undefined;
+
+  prompts.outro(`Creating ${directory}`);
+
+  return {
+    directory,
+    preset,
+    features,
+    integrations,
+    packageManager,
+  };
+}

package/src/create.ts

@@ -1,6 +1,6 @@
-import { readFileSync } from "node:fs";
 import { mkdir, readdir, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { presetFeatureDefaults, presetIntegrationDefaults } from "./choices.js";
 import {
   type FeatureName,
   featureChoices,
@@ -11,6 +11,7 @@ import {
   type PresetName,
   type TemplateName,
 } from "./templates.js";
+import { getCliVersion } from "./version.js";
 
 /**
  * Options for creating a new Beignet app.
@@ -24,15 +25,18 @@ export type CreateOptions = {
   packageManager?: PackageManager;
   integrations?: IntegrationName[];
   force?: boolean;
+  dryRun?: boolean;
   beignetVersion?: string;
 };
 
 /**
- * Result returned after a new app is scaffolded.
+ * Result returned after a new app is scaffolded or previewed.
  */
 export type CreateResult = {
+  schemaVersion: 1;
   name: string;
   targetDir: string;
+  dryRun: boolean;
   files: string[];
   packageManager: PackageManager;
 };
@@ -58,8 +62,9 @@ export async function createProject(
     );
   }
 
+  const dryRun = Boolean(options.dryRun);
+
   await assertCanWrite(targetDir, Boolean(options.force));
-  await mkdir(targetDir, { recursive: true });
 
   const files = getTemplateFiles({
     name,
@@ -70,15 +75,21 @@ export async function createProject(
     integrations,
   });
 
-  for (const file of files) {
-    const destination = path.join(targetDir, file.path);
-    await mkdir(path.dirname(destination), { recursive: true });
-    await writeFile(destination, file.content);
+  if (!dryRun) {
+    await mkdir(targetDir, { recursive: true });
+
+    for (const file of files) {
+      const destination = path.join(targetDir, file.path);
+      await mkdir(path.dirname(destination), { recursive: true });
+      await writeFile(destination, file.content);
+    }
   }
 
   return {
+    schemaVersion: 1,
     name,
     targetDir,
+    dryRun,
     files: files.map((file) => file.path),
     packageManager,
   };
@@ -88,13 +99,7 @@ function resolveFeatures(
   preset: PresetName,
   explicitFeatures: FeatureName[],
 ): FeatureName[] {
-  const features = new Set<FeatureName>();
-
-  if (preset === "standard") {
-    for (const feature of featureChoices) {
-      features.add(feature);
-    }
-  }
+  const features = new Set<FeatureName>(presetFeatureDefaults[preset]);
 
   for (const feature of explicitFeatures) {
     features.add(feature);
@@ -114,13 +119,9 @@ function resolveIntegrations(
   preset: PresetName,
   explicitIntegrations: IntegrationName[],
 ): IntegrationName[] {
-  const integrations = new Set<IntegrationName>();
-
-  if (preset === "standard") {
-    integrations.add("better-auth");
-    integrations.add("drizzle-turso");
-    integrations.add("pino");
-  }
+  const integrations = new Set<IntegrationName>(
+    presetIntegrationDefaults[preset],
+  );
 
   for (const integration of explicitIntegrations) {
     integrations.add(integration);
@@ -132,16 +133,8 @@ function resolveIntegrations(
 }
 
 function getDefaultBeignetVersion(): string {
-  try {
-    const packageJsonUrl = new URL("../package.json", import.meta.url);
-    const packageJson = JSON.parse(readFileSync(packageJsonUrl, "utf8")) as {
-      version?: string;
-    };
-
-    return packageJson.version ? `^${packageJson.version}` : "latest";
-  } catch {
-    return "latest";
-  }
+  const version = getCliVersion();
+  return version === "0.0.0" ? "latest" : `^${version}`;
 }
 
 function normalizeProjectName(name: string): string {

package/src/db.ts

@@ -21,6 +21,7 @@ export type RunDatabaseCommandOptions = {
  * Result returned by a database lifecycle command.
  */
 export type RunDatabaseCommandResult = {
+  schemaVersion: 1;
   command: DatabaseCommand;
   cwd: string;
   script: string;
@@ -56,18 +57,20 @@ export async function runDatabaseCommand(
   const cwd = path.resolve(options.cwd ?? process.cwd());
   const script = databaseScripts[options.command];
   const packageJson = await readPackageJson(cwd);
+  const scriptCommand = packageJson.scripts?.[script];
 
-  if (!packageJson.scripts?.[script]) {
-    throw new Error(
-      `Missing package.json script "${script}". Add it to this Beignet app before running beignet db ${options.command}.`,
-    );
+  if (!scriptCommand) {
+    throw new Error(missingDatabaseScriptMessage(options.command, script));
   }
 
+  await assertDatabaseCommandPreflight(cwd, options.command, scriptCommand);
+
   const runner = await detectPackageManager(cwd);
   const args = ["run", script];
 
   if (options.dryRun) {
     return {
+      schemaVersion: 1,
       command: options.command,
       cwd,
       script,
@@ -83,6 +86,7 @@ export async function runDatabaseCommand(
   });
 
   return {
+    schemaVersion: 1,
     command: options.command,
     cwd,
     script,
@@ -96,6 +100,58 @@ export async function runDatabaseCommand(
   };
 }
 
+async function assertDatabaseCommandPreflight(
+  cwd: string,
+  command: DatabaseCommand,
+  scriptCommand: string,
+): Promise<void> {
+  if (
+    (command === "generate" || command === "migrate") &&
+    /\bdrizzle-kit\b/.test(scriptCommand) &&
+    !hasExplicitDrizzleConfigFlag(scriptCommand) &&
+    !(await exists(path.join(cwd, "drizzle.config.ts"))) &&
+    !(await exists(path.join(cwd, "drizzle.config.mts"))) &&
+    !(await exists(path.join(cwd, "drizzle.config.js"))) &&
+    !(await exists(path.join(cwd, "drizzle.config.mjs")))
+  ) {
+    throw new Error(
+      `Missing Drizzle config. beignet db ${command} runs "${scriptCommand}", but no drizzle.config.ts, drizzle.config.mts, drizzle.config.js, or drizzle.config.mjs exists in the app root.`,
+    );
+  }
+
+  const standardEntrypoints: Partial<Record<DatabaseCommand, string>> = {
+    seed: "infra/db/seed.ts",
+    reset: "infra/db/reset.ts",
+  };
+  const standardEntrypoint = standardEntrypoints[command];
+  if (
+    standardEntrypoint &&
+    scriptCommand.includes(standardEntrypoint) &&
+    !(await exists(path.join(cwd, standardEntrypoint)))
+  ) {
+    throw new Error(
+      `Missing database ${command} entrypoint ${standardEntrypoint}. beignet db ${command} runs "${scriptCommand}", so restore ${standardEntrypoint} or update package.json script "${databaseScripts[command]}".`,
+    );
+  }
+}
+
+function hasExplicitDrizzleConfigFlag(scriptCommand: string): boolean {
+  return /(?:^|\s)--config(?:=|\s)/.test(scriptCommand);
+}
+
+function missingDatabaseScriptMessage(
+  command: DatabaseCommand,
+  script: string,
+): string {
+  if (command === "generate" || command === "migrate") {
+    return `Missing package.json script "${script}". Standard Drizzle apps use "${script}": "drizzle-kit ${command}" with drizzle.config.ts at the app root.`;
+  }
+
+  const entrypoint =
+    command === "seed" ? "infra/db/seed.ts" : "infra/db/reset.ts";
+  return `Missing package.json script "${script}". Standard Drizzle apps use "${script}": "bun ${entrypoint}" so beignet db ${command} can run the app-owned ${command} entrypoint.`;
+}
+
 async function readPackageJson(cwd: string): Promise<PackageJson> {
   try {
     return JSON.parse(

package/src/github-annotations.ts

@@ -0,0 +1,37 @@
+/**
+ * Severity levels understood by GitHub Actions workflow commands.
+ */
+export type GithubAnnotationSeverity = "error" | "warning" | "notice";
+
+/**
+ * Format one GitHub Actions annotation workflow command.
+ *
+ * Absent properties are omitted and the message is percent-encoded so
+ * multiline messages survive the single-line command format.
+ */
+export function formatGithubAnnotation(annotation: {
+  severity: GithubAnnotationSeverity;
+  message: string;
+  file?: string;
+  line?: number;
+  col?: number;
+}): string {
+  const properties = [
+    annotation.file === undefined ? undefined : `file=${annotation.file}`,
+    annotation.line === undefined ? undefined : `line=${annotation.line}`,
+    annotation.col === undefined ? undefined : `col=${annotation.col}`,
+  ].filter((property): property is string => property !== undefined);
+  const propertySection =
+    properties.length > 0 ? ` ${properties.join(",")}` : "";
+
+  return `::${annotation.severity}${propertySection}::${encodeGithubAnnotationMessage(
+    annotation.message,
+  )}`;
+}
+
+function encodeGithubAnnotationMessage(message: string): string {
+  return message
+    .replaceAll("%", "%25")
+    .replaceAll("\r", "%0D")
+    .replaceAll("\n", "%0A");
+}