alchemy 0.37.1 → 0.38.0

package/bin/alchemy.ts

@@ -1,93 +1,88 @@
 #!/usr/bin/env node
-import { parseArgs } from "node:util";
-import { bootstrapS3 } from "./bootstrap-s3.ts";
-import { createAlchemy } from "./create-alchemy.ts";
 
-// Parse command-line arguments. We allow unknown flags because different
-// sub-commands may accept different sets.
-const { values, positionals } = parseArgs({
-  allowPositionals: true,
-  // We keep the option list flat – sub-commands will decide which ones they care about.
-  options: {
-    template: { type: "string" },
-    yes: { type: "boolean", short: "y" },
-    overwrite: { type: "boolean" },
-    help: { type: "boolean", short: "h" },
-    version: { type: "boolean", short: "v" },
-    region: { type: "string" },
-    prefix: { type: "string" },
-  },
-});
-
-// First positional is the sub-command (e.g. `create`)
-const command = positionals.shift();
-
-const usage = `Usage: alchemy <command> [options]
-
-Available commands:
-  create    Scaffold a new project
-  bootstrap Bootstrap cloud resources for alchemy
-
-Bootstrap options:
-  --region    AWS region (defaults to AWS profile default)
-  --prefix    S3 bucket name prefix (default: alchemy-state)
-`;
+import { createCli, trpcServer, zod as z } from "trpc-cli";
+import { createAlchemy } from "./commands/create.ts";
+import { getPackageVersion } from "./services/get-package-version.ts";
+import {
+  PackageManagerSchema,
+  ProjectNameSchema,
+  TemplateSchema,
+  type CreateInput,
+} from "./types.ts";
 
-if (!command) {
-  console.error(usage);
-  process.exit(1);
-}
+const t = trpcServer.initTRPC.create();
 
-switch (command) {
-  case "create": {
-    // The first remaining positional is treated as the project name.
-    const name = positionals.shift();
-
-    // If the user explicitly requested help or version, forward the flags even
-    // when no project name is provided so the underlying handler can display
-    // the appropriate information.
-    if (values.help || values.version) {
-      await createAlchemy({
+const router = t.router({
+  create: t.procedure
+    .meta({
+      description: "Create a new Alchemy project",
+    })
+    .input(
+      z.tuple([
+        ProjectNameSchema.optional(),
+        z
+          .object({
+            template: TemplateSchema.optional(),
+            packageManager: PackageManagerSchema.optional(),
+            yes: z
+              .boolean()
+              .optional()
+              .default(false)
+              .describe("Skip prompts and use defaults"),
+            overwrite: z
+              .boolean()
+              .optional()
+              .default(false)
+              .describe("Overwrite existing directory"),
+            bun: z
+              .boolean()
+              .optional()
+              .default(false)
+              .describe("Use Bun as the package manager"),
+            npm: z
+              .boolean()
+              .optional()
+              .default(false)
+              .describe("Use npm as the package manager"),
+            pnpm: z
+              .boolean()
+              .optional()
+              .default(false)
+              .describe("Use pnpm as the package manager"),
+            yarn: z
+              .boolean()
+              .optional()
+              .default(false)
+              .describe("Use Yarn as the package manager"),
+            install: z
+              .boolean()
+              .optional()
+              .describe("Install dependencies after scaffolding"),
+          })
+          .optional()
+          .default({}),
+      ]),
+    )
+    .mutation(async ({ input }) => {
+      const [name, options] = input;
+      const isTest = process.env.NODE_ENV === "test";
+      const combinedInput: CreateInput = {
         name,
-        template: values.template as string | undefined,
-        yes: values.yes as boolean | undefined,
-        overwrite: values.overwrite as boolean | undefined,
-        help: values.help as boolean | undefined,
-        version: values.version as boolean | undefined,
-      });
-      break;
-    }
-
-    await createAlchemy({
-      name,
-      template: values.template as string | undefined,
-      yes: values.yes as boolean | undefined,
-      overwrite: values.overwrite as boolean | undefined,
-      help: values.help as boolean | undefined,
-      version: values.version as boolean | undefined,
-    });
-    break;
-  }
+        ...options,
+        yes: isTest || options.yes,
+      };
+      await createAlchemy(combinedInput);
+    }),
+});
 
-  case "bootstrap": {
-    const subcommand = positionals.shift();
+export type AppRouter = typeof router;
 
-    if (subcommand === "s3") {
-      await bootstrapS3({
-        region: values.region as string | undefined,
-        prefix: values.prefix as string | undefined,
-        help: values.help as boolean | undefined,
-      });
-    } else {
-      console.error(`Unknown bootstrap subcommand: ${subcommand || "(none)"}`);
-      console.error("Available bootstrap subcommands:");
-      console.error("  s3    Create S3 bucket for state storage");
-      process.exit(1);
-    }
-    break;
-  }
+const cli = createCli({
+  router,
+  name: "alchemy",
+  version: getPackageVersion(),
+  description:
+    "🧪 Welcome to Alchemy! Creating infrastructure as code with JavaScript and TypeScript.",
+});
 
-  default:
-    console.error(`Unknown command: ${command}`);
-    process.exit(1);
-}
+cli.run();

package/bin/commands/create.ts

@@ -0,0 +1,263 @@
+import {
+  cancel,
+  confirm,
+  intro,
+  isCancel,
+  log,
+  note,
+  outro,
+  select,
+  spinner,
+  text,
+} from "@clack/prompts";
+import * as fs from "fs-extra";
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import pc from "picocolors";
+
+import { throwWithContext } from "../errors.ts";
+import { detectPackageManager } from "../services/package-manager.ts";
+import { copyTemplate } from "../services/template-manager.ts";
+import type { CreateInput, ProjectContext, TemplateType } from "../types.ts";
+import { ProjectNameSchema, TEMPLATE_DEFINITIONS } from "../types.ts";
+
+const isTest = process.env.NODE_ENV === "test";
+
+async function createProjectContext(
+  cliOptions: CreateInput,
+): Promise<ProjectContext> {
+  const detectedPm = detectPackageManager();
+  const options = { yes: isTest, ...cliOptions };
+
+  let name: string;
+  if (options.name) {
+    const result = ProjectNameSchema.safeParse(options.name);
+    if (!result.success) {
+      throw new Error(
+        `Invalid project name: ${result.error.errors[0]?.message}`,
+      );
+    }
+    name = options.name;
+    log.info(`Using project name: ${pc.yellow(name)}`);
+  } else {
+    const nameResult = await text({
+      message: "What is your project name?",
+      placeholder: "my-alchemy-app",
+      validate: (value) => {
+        const result = ProjectNameSchema.safeParse(value);
+        return result.success ? undefined : result.error.errors[0]?.message;
+      },
+    });
+
+    if (isCancel(nameResult)) {
+      cancel(pc.red("Operation cancelled."));
+      process.exit(0);
+    }
+
+    name = nameResult;
+  }
+
+  let selectedTemplate: TemplateType;
+  if (options.template) {
+    selectedTemplate = options.template;
+    log.info(`Using template: ${pc.yellow(selectedTemplate)}`);
+  } else {
+    const templateResult = await select({
+      message: "Which template would you like to use?",
+      options: TEMPLATE_DEFINITIONS.map((t) => ({
+        label: t.description,
+        value: t.name as TemplateType,
+      })),
+    });
+
+    if (isCancel(templateResult)) {
+      cancel(pc.red("Operation cancelled."));
+      process.exit(0);
+    }
+
+    selectedTemplate = templateResult;
+  }
+
+  const templateDefinition = TEMPLATE_DEFINITIONS.find(
+    (t) => t.name === selectedTemplate,
+  );
+  if (!templateDefinition) {
+    throw new Error(
+      `Template '${pc.yellow(selectedTemplate)}' not found. Available templates: ${TEMPLATE_DEFINITIONS.map((t) => pc.cyan(t.name)).join(", ")}`,
+    );
+  }
+
+  const path = resolve(process.cwd(), name);
+  let packageManager = options.packageManager || detectedPm;
+
+  // Override package manager if specific flags are provided
+  if (options.bun) packageManager = "bun";
+  else if (options.npm) packageManager = "npm";
+  else if (options.pnpm) packageManager = "pnpm";
+  else if (options.yarn) packageManager = "yarn";
+
+  let shouldInstall = true;
+  if (options.install !== undefined) {
+    shouldInstall = options.install;
+    log.info(
+      `Dependencies installation: ${pc.yellow(shouldInstall ? "enabled" : "disabled")}`,
+    );
+  } else if (!options.yes) {
+    const installResult = await confirm({
+      message: "Install dependencies?",
+      initialValue: true,
+    });
+
+    if (isCancel(installResult)) {
+      cancel(pc.red("Operation cancelled."));
+      process.exit(0);
+    }
+
+    shouldInstall = installResult;
+  }
+
+  return {
+    name,
+    path,
+    template: selectedTemplate,
+    packageManager,
+    isTest,
+    options: {
+      ...options,
+      install: shouldInstall,
+    },
+  };
+}
+
+async function handleDirectoryOverwrite(
+  context: ProjectContext,
+): Promise<void> {
+  if (!existsSync(context.path)) {
+    return;
+  }
+
+  let shouldOverwrite = false;
+
+  if (context.options.overwrite) {
+    shouldOverwrite = true;
+    log.warn(
+      `Directory ${pc.yellow(context.name)} already exists. Overwriting due to ${pc.cyan("--overwrite")} flag.`,
+    );
+  } else {
+    const overwriteResult = await confirm({
+      message: `Directory ${pc.yellow(context.name)} already exists. Overwrite?`,
+      initialValue: false,
+    });
+
+    if (isCancel(overwriteResult)) {
+      cancel(pc.red("Operation cancelled."));
+      process.exit(0);
+    }
+
+    shouldOverwrite = overwriteResult;
+  }
+
+  if (!shouldOverwrite) {
+    cancel(pc.red("Operation cancelled."));
+    process.exit(0);
+  }
+
+  const s = spinner();
+  s.start(`Removing existing directory: ${pc.yellow(context.path)}`);
+  try {
+    await fs.rm(context.path, { recursive: true, force: true });
+    s.stop(`Directory ${pc.yellow(context.path)} removed.`);
+  } catch (error) {
+    s.stop(pc.red(`Failed to remove directory ${pc.yellow(context.path)}.`));
+    throwWithContext(error, "Directory removal failed");
+  }
+}
+
+async function initializeTemplate(context: ProjectContext): Promise<void> {
+  const templateDefinition = TEMPLATE_DEFINITIONS.find(
+    (t) => t.name === context.template,
+  );
+  if (!templateDefinition) {
+    throw new Error(`Template definition not found for: ${context.template}`);
+  }
+
+  try {
+    await copyTemplate(context.template, context);
+  } catch (error) {
+    throwWithContext(
+      error,
+      `Template initialization failed for '${context.template}'`,
+    );
+  }
+
+  // Create .gitignore if it doesn't exist
+  const gitignorePath = join(context.path, ".gitignore");
+  if (!existsSync(gitignorePath)) {
+    try {
+      await fs.writeFile(
+        gitignorePath,
+        "node_modules/\n.env\n.env.local\ndist/\nlib/\n.wrangler/\nwrangler.jsonc\n*.tsbuildinfo\n",
+      );
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      log.warn(`Failed to create .gitignore: ${errorMsg}`);
+    }
+  }
+}
+
+export async function createAlchemy(cliOptions: CreateInput): Promise<void> {
+  try {
+    intro(pc.cyan("🧪 Welcome to Alchemy!"));
+    log.info("Creating a new Alchemy project...");
+
+    const context = await createProjectContext(cliOptions);
+
+    log.info(`Detected package manager: ${pc.green(context.packageManager)}`);
+
+    await handleDirectoryOverwrite(context);
+
+    await initializeTemplate(context);
+
+    const installInstructions =
+      context.options.install === false
+        ? `
+${pc.cyan("📦 Install dependencies:")}
+   cd ${context.name}
+   ${context.packageManager} install
+
+`
+        : "";
+
+    note(
+      `
+${pc.cyan("📁 Navigate to your project:")}
+   cd ${context.name}
+
+${installInstructions}${pc.cyan("🚀 Deploy your project:")}
+   ${context.packageManager} run deploy
+
+${pc.cyan("🧹 Destroy your project:")}
+   ${context.packageManager} run destroy
+
+${pc.cyan("📚 Learn more:")}
+   https://alchemy.run
+`,
+      "Next Steps:",
+    );
+
+    outro(
+      pc.green(`✅ Project ${pc.yellow(context.name)} created successfully!`),
+    );
+  } catch (error) {
+    log.error("An unexpected error occurred:");
+    if (error instanceof Error) {
+      log.error(`${pc.red("Error:")} ${error.message}`);
+      if (error.stack && process.env.DEBUG) {
+        log.error(`${pc.gray("Stack trace:")}\n${error.stack}`);
+      }
+    } else {
+      log.error(pc.red(String(error)));
+    }
+    process.exit(1);
+  }
+}

package/bin/constants.ts

@@ -0,0 +1,13 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { getPackageVersion } from "./services/get-package-version.ts";
+
+const __filename = fileURLToPath(import.meta.url);
+const distPath = path.dirname(__filename);
+export const PKG_ROOT = path.join(distPath, "../");
+
+export const dependencyVersionMap = {
+  alchemy: getPackageVersion(),
+} as const;
+
+export type DependencyVersionMap = keyof typeof dependencyVersionMap;

package/bin/errors.ts

@@ -0,0 +1,11 @@
+import { log } from "@clack/prompts";
+import pc from "picocolors";
+
+export function throwWithContext(error: unknown, context: string): never {
+  const errorMsg = error instanceof Error ? error.message : String(error);
+  log.error(pc.red(`❌ ${context}`));
+  log.error(pc.gray(`   ${errorMsg}`));
+  throw new Error(`${context}: ${errorMsg}`, {
+    cause: error instanceof Error ? error : new Error(String(error)),
+  });
+}

package/bin/services/dependencies.ts

@@ -0,0 +1,47 @@
+import { log } from "@clack/prompts";
+import fs from "fs-extra";
+import path from "node:path";
+
+import {
+  type DependencyVersionMap,
+  dependencyVersionMap,
+} from "../constants.ts";
+
+export const addPackageDependencies = async (opts: {
+  dependencies?: DependencyVersionMap[];
+  devDependencies?: DependencyVersionMap[];
+  projectDir: string;
+}): Promise<void> => {
+  const { dependencies = [], devDependencies = [], projectDir } = opts;
+
+  const pkgJsonPath = path.join(projectDir, "package.json");
+
+  const pkgJson = await fs.readJson(pkgJsonPath);
+
+  if (!pkgJson.dependencies) pkgJson.dependencies = {};
+  if (!pkgJson.devDependencies) pkgJson.devDependencies = {};
+
+  for (const pkgName of dependencies) {
+    const version = dependencyVersionMap[pkgName];
+    if (version) {
+      pkgJson.dependencies[pkgName] = version;
+    } else {
+      log.warn(`Warning: Dependency ${pkgName} not found in version map.`);
+    }
+  }
+
+  for (const pkgName of devDependencies) {
+    const version = dependencyVersionMap[pkgName];
+    if (version) {
+      pkgJson.devDependencies[pkgName] = version;
+    } else {
+      log.warn(`Warning: Dev dependency ${pkgName} not found in version map.`);
+    }
+  }
+
+  await fs.writeJson(pkgJsonPath, pkgJson, {
+    spaces: 2,
+  });
+};
+
+export const addPackageDependency = addPackageDependencies;

package/bin/services/get-package-version.ts

@@ -0,0 +1,11 @@
+import fs from "fs-extra";
+import path from "node:path";
+import { PKG_ROOT } from "../constants.ts";
+
+export const getPackageVersion = () => {
+  const packageJsonPath = path.join(PKG_ROOT, "package.json");
+
+  const packageJsonContent = fs.readJSONSync(packageJsonPath);
+
+  return packageJsonContent.version ?? "1.0.0";
+};

package/bin/services/package-manager.ts

@@ -0,0 +1,113 @@
+import { log } from "@clack/prompts";
+import { execa } from "execa";
+import * as fs from "fs-extra";
+import type { PackageManager, ProjectContext } from "../types.ts";
+
+export function detectPackageManager(): PackageManager {
+  if (fs.pathExistsSync("bun.lockb")) return "bun";
+  if (fs.pathExistsSync("pnpm-lock.yaml")) return "pnpm";
+  if (fs.pathExistsSync("yarn.lock")) return "yarn";
+
+  if (process.env.npm_execpath?.includes("bun")) {
+    return "bun";
+  }
+
+  const userAgent = process.env.npm_config_user_agent;
+  if (userAgent) {
+    if (userAgent.startsWith("bun")) return "bun";
+    if (userAgent.startsWith("pnpm")) return "pnpm";
+    if (userAgent.startsWith("yarn")) return "yarn";
+    if (userAgent.startsWith("npm")) return "npm";
+  }
+
+  return "npm";
+}
+
+export function getPackageManagerCommands(pm: PackageManager) {
+  const commands = {
+    bun: {
+      init: "bun init -y",
+      install: "bun install",
+      add: "bun add",
+      addDev: "bun add -D",
+      run: "bun run",
+      create: "bun create",
+      x: "bunx",
+    },
+    npm: {
+      init: "npm init -y",
+      install: "npm install",
+      add: "npm install",
+      addDev: "npm install --save-dev",
+      run: "npm run",
+      create: "npm create",
+      x: "npx",
+    },
+    pnpm: {
+      init: "pnpm init",
+      install: "pnpm install",
+      add: "pnpm add",
+      addDev: "pnpm add -D",
+      run: "pnpm run",
+      create: "pnpm create",
+      x: "pnpm dlx",
+    },
+    yarn: {
+      init: "yarn init -y",
+      install: "yarn install",
+      add: "yarn add",
+      addDev: "yarn add -D",
+      run: "yarn",
+      create: "yarn create",
+      x: "yarn dlx",
+    },
+  };
+
+  return commands[pm];
+}
+
+export async function installDependencies(
+  context: ProjectContext,
+  {
+    dependencies,
+    devDependencies,
+    cwd,
+  }: {
+    dependencies?: string[];
+    devDependencies?: string[];
+    cwd?: string;
+  } = {},
+): Promise<void> {
+  const targetCwd = cwd || context.path;
+  const pm = context.packageManager;
+  const commands = getPackageManagerCommands(pm);
+
+  try {
+    if (!dependencies && !devDependencies) {
+      await execa(commands.install, {
+        cwd: targetCwd,
+        shell: true,
+        stdio: "pipe",
+      });
+    }
+
+    if (dependencies) {
+      await execa(`${commands.add} ${dependencies.join(" ")}`, {
+        cwd: targetCwd,
+        shell: true,
+        stdio: "pipe",
+      });
+    }
+
+    if (devDependencies) {
+      await execa(`${commands.addDev} ${devDependencies.join(" ")}`, {
+        cwd: targetCwd,
+        shell: true,
+        stdio: "pipe",
+      });
+    }
+  } catch (error) {
+    log.error("Failed to install dependencies");
+    throw error;
+  }
+}