[r5n-83] actions command

packages/core/src/abstract-cli.ts

@@ -128,19 +128,22 @@ export abstract class AbstractCLI {
   private handleError(error: unknown) {
     if (this.metadata.onError?.(error)) return;
 
-    if (error instanceof Cancel) return;
+    if (error instanceof Cancel) {
+      process.exit(0);
+    }
 
     if (error instanceof Exit) {
       log.warn(color.yellow(error.message));
       if (error.hint) log.info(color.dim(error.hint));
-      return;
+      process.exit(0);
     }
 
     if (error instanceof Error) {
       log.error(color.red(error.message));
-      return;
+      process.exit(1);
     }
 
     console.error(color.red("Error:"), error);
+    process.exit(1);
   }
 }

packages/sisyphus/build.ts

@@ -1,3 +1,6 @@
+import { cp } from "node:fs/promises";
 import { bunPackageBuilder } from "@r5n/tools/builder";
 
 await bunPackageBuilder({ banner: "#!/usr/bin/env bun", maxSize: 150, packages: "bundle", target: "bun", type: "cli" });
+
+await cp("src/commands/actions/templates", "dist/templates", { recursive: true });

packages/sisyphus/src/cli.ts

@@ -1,6 +1,7 @@
 import { AbstractCLI, ConfigManager } from "@r5n/cli-core";
 import { version } from "../package.json";
 import {
+  ActionsCommand,
   CheckCommand,
   InitCommand,
   MigrateCommand,
@@ -27,6 +28,7 @@ class SisyphusCLI extends AbstractCLI {
 
   init() {
     this.registerCommands([
+      new ActionsCommand(),
       new CheckCommand(),
       new InitCommand(),
       new MigrateCommand(),

packages/sisyphus/src/commands/actions/CiGenerator.ts

@@ -0,0 +1,106 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { Provider } from "../../providers";
+
+export type WorkflowType = "create-stone" | "release";
+
+export type WorkflowFile = { path: string; content: string };
+
+export type WorkflowConfig = { name: string; description: string };
+
+export const WORKFLOW_CONFIGS: Record<WorkflowType, WorkflowConfig> = {
+  "create-stone": {
+    description: "When a PR is merged, create stone and update release PR",
+    name: "Handle PR merge (stone + release PR)",
+  },
+  release: { description: "When the release PR is merged, publish packages", name: "Publish release" },
+};
+
+const TEMPLATES_DIR = join(dirname(fileURLToPath(import.meta.url)), "templates");
+
+const TEMPLATE_FILENAMES: Record<WorkflowType, string> = {
+  "create-stone": "sis-create-stone.yml",
+  release: "sis-release.yml",
+};
+
+export abstract class CiGenerator {
+  abstract readonly provider: Provider;
+  protected abstract readonly outputDir: string;
+
+  async generate(workflows: WorkflowType[]): Promise<WorkflowFile[]> {
+    const files: WorkflowFile[] = [];
+
+    for (const type of workflows) {
+      const content = await this.readTemplate(type);
+      const path = this.getOutputPath(type);
+      files.push({ content, path });
+    }
+
+    return files;
+  }
+
+  getExistingFiles(workflows: WorkflowType[]): string[] {
+    return workflows.map((type) => this.getOutputPath(type)).filter((path) => existsSync(path));
+  }
+
+  protected async readTemplate(type: WorkflowType): Promise<string> {
+    const templatePath = join(TEMPLATES_DIR, this.provider, TEMPLATE_FILENAMES[type]);
+    return readFile(templatePath, "utf-8");
+  }
+
+  protected abstract getOutputPath(type: WorkflowType): string;
+}
+
+export class GitHubCiGenerator extends CiGenerator {
+  readonly provider = "github" as const;
+  protected readonly outputDir = ".github/workflows";
+
+  protected getOutputPath(type: WorkflowType): string {
+    return join(this.outputDir, TEMPLATE_FILENAMES[type]);
+  }
+}
+
+const GITLAB_SISYPHUS_FILE = ".gitlab-ci-sisyphus.yml";
+
+export class GitLabCiGenerator extends CiGenerator {
+  readonly provider = "gitlab" as const;
+  protected readonly outputDir = ".";
+
+  async generate(workflows: WorkflowType[]): Promise<WorkflowFile[]> {
+    const sections: string[] = [];
+
+    sections.push("stages:\n  - sisyphus\n");
+
+    for (const type of workflows) {
+      const content = await this.readTemplate(type);
+      sections.push(content);
+    }
+
+    return [{ content: sections.join("\n"), path: GITLAB_SISYPHUS_FILE }];
+  }
+
+  getExistingFiles(_workflows: WorkflowType[]): string[] {
+    return existsSync(GITLAB_SISYPHUS_FILE) ? [GITLAB_SISYPHUS_FILE] : [];
+  }
+
+  getIncludeInstruction(): string {
+    return `include:\n  - local: '${GITLAB_SISYPHUS_FILE}'`;
+  }
+
+  protected getOutputPath(_type: WorkflowType): string {
+    return GITLAB_SISYPHUS_FILE;
+  }
+}
+
+export function createCiGenerator(provider: Provider): CiGenerator {
+  switch (provider) {
+    case "github":
+      return new GitHubCiGenerator();
+    case "gitlab":
+      return new GitLabCiGenerator();
+    default:
+      throw new Error(`CI generation is not supported for ${provider}`);
+  }
+}

packages/sisyphus/src/commands/actions/index.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from "../../base-command";
+import { ActionsInitCommand } from "./init";
+import { ActionsReleasePrCommand } from "./release-pr";
+
+export class ActionsCommand extends BaseCommand {
+  name = "actions";
+  description = "CI/CD integration";
+
+  init() {
+    this.registerSubcommands([new ActionsInitCommand(), new ActionsReleasePrCommand()]);
+  }
+}

packages/sisyphus/src/commands/actions/init.ts

@@ -0,0 +1,107 @@
+import { existsSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { args, color, confirm, Exit, log, multiselect, note } from "@r5n/cli-core";
+import { BaseCommand, type Ctx } from "../../base-command";
+import { detectProvider } from "../../providers";
+import { createCiGenerator, GitLabCiGenerator, WORKFLOW_CONFIGS, type WorkflowType } from "./CiGenerator";
+
+const PROVIDER_LABELS = { bitbucket: "Bitbucket Pipelines", github: "GitHub Actions", gitlab: "GitLab CI" };
+
+const initArgs = args({
+  all: { alias: "a", default: false, description: "Install all workflows", type: "boolean" },
+  createStone: { default: false, description: "Install create-stone workflow", type: "boolean" },
+  dryRun: { alias: "d", default: false, description: "Preview without writing files", type: "boolean" },
+  release: { default: false, description: "Install release workflow", type: "boolean" },
+  yes: { alias: "y", default: false, description: "Skip confirmation prompts", type: "boolean" },
+});
+
+type InitCtx = Ctx<typeof initArgs>;
+
+export class ActionsInitCommand extends BaseCommand {
+  name = "init";
+  description = "Set up CI workflows for automated releases";
+  args = initArgs;
+  prompts = true;
+
+  async execute(ctx: InitCtx) {
+    const provider = await detectProvider();
+    const generator = createCiGenerator(provider);
+
+    log.info(`Detected ${color.bold(PROVIDER_LABELS[provider])} repository\n`);
+
+    const selected = await this.selectWorkflows(ctx);
+
+    if (selected.length === 0) {
+      log.info(color.dim("No workflows selected"));
+      return;
+    }
+
+    const existing = generator.getExistingFiles(selected);
+    if (existing.length > 0 && !ctx.args.yes) {
+      if (!ctx.interactive) {
+        throw new Exit(`Workflows already exist: ${existing.join(", ")}`, "Use --yes to overwrite existing workflows");
+      }
+      log.warn(`The following files already exist:\n${existing.map((f) => `  ${f}`).join("\n")}`);
+      const overwrite = await confirm({ initialValue: false, message: "Overwrite existing files?" });
+      if (!overwrite) return;
+    }
+
+    const files = await generator.generate(selected);
+
+    if (ctx.args.dryRun) {
+      for (const file of files) {
+        log.info(`\n${color.bold(file.path)}:`);
+        log.info(color.dim(file.content));
+      }
+      return;
+    }
+
+    for (const file of files) {
+      const dir = dirname(file.path);
+      if (dir !== "." && !existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+      }
+      await writeFile(file.path, file.content, "utf-8");
+    }
+
+    note(files.map((f) => `  ${color.green("+")} ${f.path}`).join("\n"), color.green("CI workflows created"));
+
+    if (generator instanceof GitLabCiGenerator) {
+      log.info(`\nAdd this to your ${color.bold(".gitlab-ci.yml")}:\n`);
+      log.info(color.cyan(generator.getIncludeInstruction()));
+      log.info("");
+    }
+
+    log.info(color.dim("Commit and push these files to enable the workflows."));
+  }
+
+  private async selectWorkflows(ctx: InitCtx): Promise<WorkflowType[]> {
+    const fromFlags = this.getWorkflowsFromFlags(ctx);
+    if (fromFlags.length > 0) return fromFlags;
+
+    if (!ctx.interactive) {
+      throw new Exit("No workflows specified", "Use --all or specify workflows with --createStone, --release");
+    }
+
+    return multiselect({
+      initialValues: Object.keys(WORKFLOW_CONFIGS) as WorkflowType[],
+      message: "Select workflows to create",
+      options: Object.entries(WORKFLOW_CONFIGS).map(([key, config]) => ({
+        hint: config.description,
+        label: config.name,
+        value: key as WorkflowType,
+      })),
+      required: false,
+    });
+  }
+
+  private getWorkflowsFromFlags(ctx: InitCtx): WorkflowType[] {
+    if (ctx.args.all) return Object.keys(WORKFLOW_CONFIGS) as WorkflowType[];
+
+    const selected: WorkflowType[] = [];
+    if (ctx.args.createStone) selected.push("create-stone");
+    if (ctx.args.release) selected.push("release");
+    return selected;
+  }
+}