@beignet/cli 0.0.1 → 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,7 +11,11 @@ import {
   type PresetName,
   type TemplateName,
 } from "./templates.js";
+import { getCliVersion } from "./version.js";
 
+/**
+ * Options for creating a new Beignet app.
+ */
 export type CreateOptions = {
   name: string;
   cwd?: string;
@@ -21,16 +25,25 @@ export type CreateOptions = {
   packageManager?: PackageManager;
   integrations?: IntegrationName[];
   force?: boolean;
+  dryRun?: boolean;
   beignetVersion?: string;
 };
 
+/**
+ * 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;
 };
 
+/**
+ * Create a Beignet app from a starter template.
+ */
 export async function createProject(
   options: CreateOptions,
 ): Promise<CreateResult> {
@@ -49,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,
@@ -61,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,
   };
@@ -79,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);
@@ -105,11 +119,9 @@ function resolveIntegrations(
   preset: PresetName,
   explicitIntegrations: IntegrationName[],
 ): IntegrationName[] {
-  const integrations = new Set<IntegrationName>();
-
-  if (preset === "standard") {
-    integrations.add("pino");
-  }
+  const integrations = new Set<IntegrationName>(
+    presetIntegrationDefaults[preset],
+  );
 
   for (const integration of explicitIntegrations) {
     integrations.add(integration);
@@ -121,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

@@ -0,0 +1,222 @@
+import { spawn } from "node:child_process";
+import { access, readFile } from "node:fs/promises";
+import path from "node:path";
+
+/**
+ * Database lifecycle operations supported by the Beignet CLI.
+ */
+export type DatabaseCommand = "generate" | "migrate" | "seed" | "reset";
+
+/**
+ * Options for running a database lifecycle command.
+ */
+export type RunDatabaseCommandOptions = {
+  command: DatabaseCommand;
+  cwd?: string;
+  captureOutput?: boolean;
+  dryRun?: boolean;
+};
+
+/**
+ * Result returned by a database lifecycle command.
+ */
+export type RunDatabaseCommandResult = {
+  schemaVersion: 1;
+  command: DatabaseCommand;
+  cwd: string;
+  script: string;
+  runner: string;
+  args: string[];
+  stdout?: string;
+  stderr?: string;
+  dryRun: boolean;
+  exitCode: number;
+};
+
+type PackageJson = {
+  scripts?: Record<string, string>;
+};
+
+const databaseScripts: Record<DatabaseCommand, string> = {
+  generate: "db:generate",
+  migrate: "db:migrate",
+  seed: "db:seed",
+  reset: "db:reset",
+};
+
+/**
+ * Run an app-owned database lifecycle script.
+ *
+ * Beignet owns the command surface; the app owns the actual Drizzle script.
+ * This keeps `beignet db ...` stable while leaving migrations, schema paths,
+ * database URLs, and destructive reset behavior explicit in app code.
+ */
+export async function runDatabaseCommand(
+  options: RunDatabaseCommandOptions,
+): Promise<RunDatabaseCommandResult> {
+  const cwd = path.resolve(options.cwd ?? process.cwd());
+  const script = databaseScripts[options.command];
+  const packageJson = await readPackageJson(cwd);
+  const scriptCommand = packageJson.scripts?.[script];
+
+  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,
+      runner,
+      args,
+      dryRun: true,
+      exitCode: 0,
+    };
+  }
+
+  const commandResult = await spawnCommand(runner, args, cwd, {
+    captureOutput: Boolean(options.captureOutput),
+  });
+
+  return {
+    schemaVersion: 1,
+    command: options.command,
+    cwd,
+    script,
+    runner,
+    args,
+    dryRun: false,
+    exitCode: commandResult.exitCode,
+    ...(options.captureOutput
+      ? { stdout: commandResult.stdout, stderr: commandResult.stderr }
+      : {}),
+  };
+}
+
+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(
+      await readFile(path.join(cwd, "package.json"), "utf8"),
+    ) as PackageJson;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      throw new Error(
+        "Could not find package.json. Run beignet db from the app root.",
+      );
+    }
+    throw error;
+  }
+}
+
+async function detectPackageManager(cwd: string): Promise<string> {
+  if (await exists(path.join(cwd, "bun.lock"))) return "bun";
+  if (await exists(path.join(cwd, "bun.lockb"))) return "bun";
+  if (await exists(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (await exists(path.join(cwd, "yarn.lock"))) return "yarn";
+  if (await exists(path.join(cwd, "package-lock.json"))) return "npm";
+  return "bun";
+}
+
+async function exists(filePath: string): Promise<boolean> {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function spawnCommand(
+  command: string,
+  args: readonly string[],
+  cwd: string,
+  options: { captureOutput: boolean },
+): Promise<{ exitCode: number; stdout?: string; stderr?: string }> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      env: process.env,
+      stdio: options.captureOutput ? ["ignore", "pipe", "pipe"] : "inherit",
+    });
+
+    const stdout: Buffer[] = [];
+    const stderr: Buffer[] = [];
+
+    if (options.captureOutput) {
+      child.stdout?.on("data", (chunk: Buffer) => stdout.push(chunk));
+      child.stderr?.on("data", (chunk: Buffer) => stderr.push(chunk));
+    }
+
+    child.on("error", reject);
+    child.on("close", (code) =>
+      resolve({
+        exitCode: code ?? 1,
+        ...(options.captureOutput
+          ? {
+              stdout: Buffer.concat(stdout).toString("utf8"),
+              stderr: Buffer.concat(stderr).toString("utf8"),
+            }
+          : {}),
+      }),
+    );
+  });
+}

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");
+}