alchemy 0.45.5 → 0.46.0

package/bin/alchemy.ts

@@ -1,64 +1,22 @@
 #!/usr/bin/env node
 
-import { createCli, trpcServer, zod as z } from "trpc-cli";
-import { createAlchemy } from "./commands/create.ts";
+import { createCli } from "trpc-cli";
+import { create } from "./commands/create.ts";
+import { deploy } from "./commands/deploy.ts";
+import { destroy } from "./commands/destroy.ts";
+import { dev } from "./commands/dev.ts";
+import { login } from "./commands/login.ts";
+import { run } from "./commands/run.ts";
 import { getPackageVersion } from "./services/get-package-version.ts";
-import {
-  EditorSchema,
-  PackageManagerSchema,
-  ProjectNameSchema,
-  TemplateSchema,
-  type CreateInput,
-} from "./types.ts";
-
-const t = trpcServer.initTRPC.create();
+import { t } from "./trpc.ts";
 
 const router = t.router({
-  create: t.procedure
-    .meta({
-      description: "Create a new Alchemy project",
-    })
-    .input(
-      z.tuple([
-        ProjectNameSchema.optional(),
-        z
-          .object({
-            template: TemplateSchema.optional(),
-            yes: z
-              .boolean()
-              .optional()
-              .default(false)
-              .describe("Skip prompts and use defaults"),
-            overwrite: z
-              .boolean()
-              .optional()
-              .default(false)
-              .describe("Overwrite existing directory"),
-            install: z
-              .boolean()
-              .optional()
-              .describe("Install dependencies after scaffolding"),
-            pm: PackageManagerSchema.optional().describe(
-              "Package manager to use (bun, npm, pnpm, yarn)",
-            ),
-            vibeRules: EditorSchema.optional().describe(
-              "Setup vibe-rules for the specified editor (cursor, windsurf, vscode, zed, claude-code, gemini, codex, amp, clinerules, roo, unified)",
-            ),
-          })
-          .optional()
-          .default({}),
-      ]),
-    )
-    .mutation(async ({ input }) => {
-      const [name, options] = input;
-      const isTest = process.env.NODE_ENV === "test";
-      const combinedInput: CreateInput = {
-        name,
-        ...options,
-        yes: isTest || options.yes,
-      };
-      await createAlchemy(combinedInput);
-    }),
+  create,
+  login,
+  deploy,
+  destroy,
+  dev,
+  run,
 });
 
 export type AppRouter = typeof router;

package/bin/commands/create.ts

@@ -13,122 +13,214 @@ import {
 import * as fs from "fs-extra";
 import { resolve } from "node:path";
 import pc from "picocolors";
-
+import z from "zod";
+import { detectPackageManager } from "../../src/util/detect-package-manager.ts";
 import { throwWithContext } from "../errors.ts";
-import {
-  detectPackageManager,
-  installDependencies,
-} from "../services/package-manager.ts";
+import { initializeGitRepo, isGitInstalled } from "../services/git.ts";
+import { addGitHubWorkflowToAlchemy } from "../services/github-workflow.ts";
+import { installDependencies } from "../services/package-manager.ts";
 import { copyTemplate } from "../services/template-manager.ts";
 import { ensureVibeRulesPostinstall } from "../services/vibe-rules.ts";
+import { t } from "../trpc.ts";
 import type {
   CreateInput,
   EditorType,
   ProjectContext,
   TemplateType,
 } from "../types.ts";
-import { ProjectNameSchema, TEMPLATE_DEFINITIONS } from "../types.ts";
+import {
+  EditorSchema,
+  PackageManagerSchema,
+  ProjectNameSchema,
+  TEMPLATE_DEFINITIONS,
+  TemplateSchema,
+} from "../types.ts";
 
 const isTest = process.env.NODE_ENV === "test";
 
+export const create = t.procedure
+  .meta({
+    description: "Create a new Alchemy project",
+    negateBooleans: true,
+  })
+  .input(
+    z.tuple([
+      ProjectNameSchema.optional(),
+      z.object({
+        template: TemplateSchema.optional(),
+        yes: z.boolean().optional().describe("Skip prompts and use defaults"),
+        overwrite: z
+          .boolean()
+          .optional()
+          .describe("Overwrite existing directory"),
+        install: z
+          .boolean()
+          .optional()
+          .describe("Install dependencies after scaffolding"),
+        pm: PackageManagerSchema.optional().describe(
+          "Package manager to use (bun, npm, pnpm, yarn)",
+        ),
+        vibeRules: EditorSchema.optional().describe(
+          "Setup vibe-rules for the specified editor (cursor, windsurf, vscode, zed, claude-code, gemini, codex, amp, clinerules, roo, unified)",
+        ),
+        githubActions: z
+          .boolean()
+          .optional()
+          .describe("Setup GitHub Actions for PR previews"),
+        git: z.boolean().optional().describe("Initialise a git repository"),
+      }),
+    ]),
+  )
+  .mutation(async ({ input }) => {
+    const [name, options] = input;
+    const isTest = process.env.NODE_ENV === "test";
+    const combinedInput: CreateInput = {
+      name,
+      ...options,
+      yes: isTest || options.yes,
+    };
+    await createAlchemy(combinedInput);
+  });
+
+async function createAlchemy(cliOptions: CreateInput): Promise<void> {
+  try {
+    intro(pc.cyan("🧪 Welcome to Alchemy!"));
+
+    const context = await createProjectContext(cliOptions);
+
+    await handleDirectoryOverwrite(context);
+    await initializeTemplate(context);
+    await setupVibeRules(context);
+    await setupGitHubActions(context);
+    await setupGit(context);
+
+    displayNextSteps(context);
+    displaySuccessMessage(context);
+  } catch (error) {
+    handleError(error);
+  }
+}
+
 async function createProjectContext(
   cliOptions: CreateInput,
 ): Promise<ProjectContext> {
-  const detectedPm = detectPackageManager();
+  const detectedPm = await detectPackageManager();
   const options = { yes: isTest, ...cliOptions };
 
-  let name: string;
+  const name = await getProjectName(options);
+  const selectedTemplate = await getSelectedTemplate(options);
+  const templateDefinition = getTemplateDefinition(selectedTemplate);
+  const packageManager = options.pm || detectedPm;
+  const shouldInstall = await getInstallPreference(options, packageManager);
+
+  const path = resolve(process.cwd(), name);
+
+  return {
+    name,
+    path,
+    template: selectedTemplate,
+    packageManager,
+    isTest,
+    options: {
+      ...options,
+      install: shouldInstall,
+    },
+  };
+}
+
+async function getProjectName(options: CreateInput): Promise<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;
-      },
-    });
+    return options.name;
+  }
 
-    if (isCancel(nameResult)) {
-      cancel(pc.red("Operation cancelled."));
-      process.exit(0);
-    }
+  if (options.yes) {
+    return "my-alchemy-app";
+  }
 
-    name = nameResult;
+  const nameResult = await text({
+    message: "What is your project name?",
+    placeholder: "my-alchemy-app",
+    validate: (value) => {
+      const result = ProjectNameSchema.safeParse(value);
+      if (!result.success) {
+        return result.error.issues[0]?.message || "Invalid project name";
+      }
+      return undefined;
+    },
+  });
+
+  if (isCancel(nameResult)) {
+    cancel(pc.red("Operation cancelled."));
+    process.exit(0);
   }
 
-  let selectedTemplate: TemplateType;
+  return nameResult;
+}
+
+async function getSelectedTemplate(
+  options: CreateInput,
+): Promise<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,
-      })),
-    });
+    return options.template;
+  }
 
-    if (isCancel(templateResult)) {
-      cancel(pc.red("Operation cancelled."));
-      process.exit(0);
-    }
+  if (options.yes) {
+    return "typescript";
+  }
+
+  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,
+    })),
+  });
 
-    selectedTemplate = templateResult;
+  if (isCancel(templateResult)) {
+    cancel(pc.red("Operation cancelled."));
+    process.exit(0);
   }
 
+  return templateResult;
+}
+
+function getTemplateDefinition(selectedTemplate: TemplateType) {
   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.pm || detectedPm;
+  return templateDefinition;
+}
 
-  let shouldInstall = true;
+async function getInstallPreference(
+  options: CreateInput,
+  packageManager: string,
+): Promise<boolean> {
   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,
-    });
+    return options.install;
+  }
 
-    if (isCancel(installResult)) {
-      cancel(pc.red("Operation cancelled."));
-      process.exit(0);
-    }
+  if (options.yes) {
+    return true;
+  }
 
-    shouldInstall = installResult;
+  const installResult = await confirm({
+    message: `Install dependencies? ${pc.cyan(packageManager)}`,
+    initialValue: true,
+  });
+
+  if (isCancel(installResult)) {
+    cancel(pc.red("Operation cancelled."));
+    process.exit(0);
   }
 
-  return {
-    name,
-    path,
-    template: selectedTemplate,
-    packageManager,
-    isTest,
-    options: {
-      ...options,
-      install: shouldInstall,
-    },
-  };
+  return installResult;
 }
 
 async function handleDirectoryOverwrite(
@@ -138,34 +230,41 @@ async function handleDirectoryOverwrite(
     return;
   }
 
-  let shouldOverwrite = false;
+  const shouldOverwrite = await getShouldOverwrite(context);
 
+  if (!shouldOverwrite) {
+    cancel(pc.red("Operation cancelled."));
+    process.exit(0);
+  }
+
+  await removeExistingDirectory(context);
+}
+
+async function getShouldOverwrite(context: ProjectContext): Promise<boolean> {
   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;
+    return true;
   }
 
-  if (!shouldOverwrite) {
+  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);
   }
 
+  return overwriteResult;
+}
+
+async function removeExistingDirectory(context: ProjectContext): Promise<void> {
   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.`);
@@ -179,6 +278,7 @@ 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}`);
   }
@@ -194,6 +294,32 @@ async function initializeTemplate(context: ProjectContext): Promise<void> {
 }
 
 async function setupVibeRules(context: ProjectContext): Promise<void> {
+  const selectedEditor = await getSelectedEditor(context);
+
+  if (!selectedEditor) {
+    return;
+  }
+
+  const s = spinner();
+  s.start("Configuring vibe-rules...");
+
+  try {
+    await ensureVibeRulesPostinstall(context.path, selectedEditor);
+    await installDependencies(context, {
+      devDependencies: ["vibe-rules"],
+    });
+    // we need to install dependencies to trigger the postinstall script
+    await installDependencies(context);
+    s.stop("vibe-rules configured");
+  } catch (error) {
+    s.stop("Failed to configure vibe-rules");
+    throwWithContext(error, "Failed to configure vibe-rules");
+  }
+}
+
+async function getSelectedEditor(
+  context: ProjectContext,
+): Promise<EditorType | undefined> {
   let selectedEditor: EditorType | undefined = context.options.vibeRules;
 
   if (!selectedEditor && !context.isTest && !context.options.yes) {
@@ -203,7 +329,7 @@ async function setupVibeRules(context: ProjectContext): Promise<void> {
     });
 
     if (isCancel(setupResult) || !setupResult) {
-      return;
+      return undefined;
     }
 
     const editorResult = await select({
@@ -224,63 +350,109 @@ async function setupVibeRules(context: ProjectContext): Promise<void> {
     });
 
     if (isCancel(editorResult)) {
-      return;
+      return undefined;
     }
 
     selectedEditor = editorResult;
   }
 
-  if (!selectedEditor) {
+  return selectedEditor;
+}
+
+async function setupGitHubActions(context: ProjectContext): Promise<void> {
+  const shouldSetup = await getShouldSetupGitHubActions(context);
+
+  if (!shouldSetup) {
     return;
   }
 
-  const s = spinner();
-  s.start("Configuring vibe-rules...");
-
   try {
-    await ensureVibeRulesPostinstall(context.path, selectedEditor);
+    await addGitHubWorkflowToAlchemy(context);
+  } catch (error) {
+    throwWithContext(error, "GitHub workflow setup failed");
+  }
+}
 
-    await installDependencies(context, {
-      devDependencies: ["vibe-rules"],
+async function getShouldSetupGitHubActions(
+  context: ProjectContext,
+): Promise<boolean> {
+  let shouldSetupGitHub = context.options.githubActions;
+
+  if (
+    shouldSetupGitHub === undefined &&
+    !context.isTest &&
+    !context.options.yes
+  ) {
+    const setupResult = await confirm({
+      message: "Add GitHub Actions for PR previews?",
+      initialValue: true,
     });
 
-    // we need to install dependencies to trigger the postinstall script
-    await installDependencies(context);
+    if (isCancel(setupResult) || !setupResult) {
+      return false;
+    }
 
-    s.stop("vibe-rules configured");
-  } catch (error) {
-    s.stop("Failed to configure vibe-rules");
-    throwWithContext(error, "Failed to configure vibe-rules");
+    shouldSetupGitHub = true;
   }
+
+  return shouldSetupGitHub ?? false;
 }
 
-export async function createAlchemy(cliOptions: CreateInput): Promise<void> {
+async function setupGit(context: ProjectContext): Promise<void> {
+  const gitAvailable = await isGitInstalled();
+
+  if (!gitAvailable) {
+    log.warn("Git is not installed. Skipping git initialisation.");
+    return;
+  }
+
+  const shouldInit = await getShouldInitGit(context);
+
+  if (!shouldInit) {
+    return;
+  }
+
+  const s = spinner();
+  s.start("Initialising git repository...");
+
   try {
-    intro(pc.cyan("🧪 Welcome to Alchemy!"));
-    log.info("Creating a new Alchemy project...");
+    await initializeGitRepo(context);
+    s.stop("Git repository initialised.");
+  } catch (error) {
+    s.stop(pc.red("Failed to initialise git repository"));
+    throwWithContext(error, "Git initialisation failed");
+  }
+}
 
-    const context = await createProjectContext(cliOptions);
+async function getShouldInitGit(context: ProjectContext): Promise<boolean> {
+  let shouldInit = context.options.git;
 
-    log.info(`Detected package manager: ${pc.green(context.packageManager)}`);
+  if (shouldInit === undefined && !context.isTest && !context.options.yes) {
+    const initResult = await confirm({
+      message: "Initialise a git repository?",
+      initialValue: true,
+    });
 
-    await handleDirectoryOverwrite(context);
+    if (isCancel(initResult) || !initResult) {
+      return false;
+    }
+    shouldInit = initResult;
+  }
 
-    await initializeTemplate(context);
+  return shouldInit ?? false;
+}
 
-    const installInstructions =
-      context.options.install === false
-        ? `
+function displayNextSteps(context: ProjectContext): void {
+  const installInstructions =
+    context.options.install === false
+      ? `
 ${pc.cyan("📦 Install dependencies:")}
-   cd ${context.name}
    ${context.packageManager} install
-
 `
-        : "";
-
-    await setupVibeRules(context);
+      : "";
 
-    note(
-      `
+  note(
+    `
 ${pc.cyan("📁 Navigate to your project:")}
    cd ${context.name}
 
@@ -293,22 +465,20 @@ ${pc.cyan("🧹 Destroy your project:")}
 ${pc.cyan("📚 Learn more:")}
    https://alchemy.run
 `,
-      "Next Steps:",
-    );
+    "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);
+function displaySuccessMessage(context: ProjectContext): void {
+  outro(
+    pc.green(`✅ Project ${pc.yellow(context.name)} created successfully!`),
+  );
+}
+
+function handleError(error: unknown): void {
+  if (error instanceof Error) {
+    throwWithContext(error, "Project creation failed");
+  } else {
+    throwWithContext(new Error(String(error)), "Project creation failed");
   }
 }

package/bin/commands/deploy.ts

@@ -0,0 +1,23 @@
+import z from "zod";
+import {
+  entrypoint,
+  execAlchemy,
+  execArgs,
+  watch,
+} from "../services/execute-alchemy.ts";
+import { t } from "../trpc.ts";
+
+export const deploy = t.procedure
+  .meta({
+    description: "Deploy an Alchemy project",
+  })
+  .input(
+    z.tuple([
+      entrypoint,
+      z.object({
+        ...execArgs,
+        watch,
+      }),
+    ]),
+  )
+  .mutation(async ({ input }) => execAlchemy(...input));

package/bin/commands/destroy.ts

@@ -0,0 +1,19 @@
+import z from "zod";
+import {
+  entrypoint,
+  execAlchemy,
+  execArgs,
+} from "../services/execute-alchemy.ts";
+import { t } from "../trpc.ts";
+
+export const destroy = t.procedure
+  .meta({
+    description: "Deploy an Alchemy project",
+  })
+  .input(z.tuple([entrypoint, z.object(execArgs)]))
+  .mutation(async ({ input: [main, options] }) =>
+    execAlchemy(main, {
+      ...options,
+      destroy: true,
+    }),
+  );