@dbx-tools/projen 0.9.18 → 0.9.21

package/tasks/release-please.ts

@@ -1,162 +0,0 @@
-#!/usr/bin/env -S bun
-/** Run Release Please with the generated cross-language release-unit plugin. */
-
-import { appendFileSync, readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import * as exec from "@dbx-tools/core/exec";
-import { log } from "@dbx-tools/shared-core";
-import { Command } from "commander";
-import { GitHub } from "release-please";
-import { Manifest } from "release-please/build/src/manifest.js";
-import type { Scm } from "release-please/build/src/scm.js";
-import type { ReleaseUnitGraph } from "../src/release-catalog.ts";
-import { addReleaseUnitPlugin } from "../src/release-please.ts";
-
-const logger = log.logger("projen:release-please");
-
-export interface ReleasePleaseRunOptions {
-  readonly github: Scm;
-  readonly targetBranch: string;
-  readonly graph: ReleaseUnitGraph;
-  readonly configFile?: string;
-  readonly manifestFile?: string;
-}
-
-/** Create component releases and refresh the combined release pull request. */
-export async function runReleasePlease(options: ReleasePleaseRunOptions) {
-  const configFile = options.configFile ?? "release-please-config.json";
-  const manifestFile = options.manifestFile ?? ".release-please-manifest.json";
-  const manifest = await Manifest.fromManifest(
-    options.github,
-    options.targetBranch,
-    configFile,
-    manifestFile,
-  );
-  addReleaseUnitPlugin(
-    manifest.plugins,
-    options.github,
-    options.targetBranch,
-    manifest.repositoryConfig,
-    options.graph,
-    manifestFile,
-  );
-  const releases = (await manifest.createReleases()).filter(
-    (release): release is NonNullable<typeof release> => release !== undefined,
-  );
-  const pullRequests = (await manifest.createPullRequests()).filter(
-    (pullRequest): pullRequest is NonNullable<typeof pullRequest> => pullRequest !== undefined,
-  );
-  return { releases, pullRequests };
-}
-
-function writeOutput(name: string, value: unknown): void {
-  const output = process.env.GITHUB_OUTPUT;
-  if (!output) return;
-  appendFileSync(output, `${name}=${JSON.stringify(value)}\n`);
-}
-
-/** Parse GitHub owner and repository from HTTPS, SSH, or SSH-alias syntax. */
-export function parseGitHubRepository(remote: string): { owner: string; repo: string } {
-  const location = remote
-    .replace(/^git@[^:]+:/, "")
-    .replace(/^ssh:\/\/git@[^/]+\//, "")
-    .replace(/^https?:\/\/[^/]+\//, "")
-    .replace(/\.git$/, "");
-  const [owner, repo, ...extra] = location.split("/");
-  if (!owner || !repo || extra.length > 0) {
-    throw new Error(`Could not resolve GitHub repository from ${remote}`);
-  }
-  return { owner, repo };
-}
-
-/** Resolve GitHub owner and repository from environment or the configured remote. */
-export function repositoryCoordinates(root: string): { owner: string; repo: string } {
-  const configured = process.env.GITHUB_REPOSITORY;
-  const remote = configured
-    ? configured
-    : (exec
-        .spawnSync("git", ["remote", "get-url", "origin"], {
-          cwd: root,
-          stdout: "capture",
-          stderr: "ignore",
-          stdin: "ignore",
-          check: true,
-        })
-        .stdout?.trim() ?? "");
-  return parseGitHubRepository(remote);
-}
-
-function githubToken(): string {
-  if (process.env.GITHUB_TOKEN) return process.env.GITHUB_TOKEN;
-  return (
-    exec
-      .spawnSync("gh", ["auth", "token"], {
-        stdout: "capture",
-        stderr: "inherit",
-        stdin: "ignore",
-        check: true,
-      })
-      .stdout?.trim() ?? ""
-  );
-}
-
-if (import.meta.main) {
-  await new Command()
-    .option("--owner <owner>", "GitHub repository owner")
-    .option("--repo <repo>", "GitHub repository name")
-    .option("--target-branch <branch>", "release target branch", "main")
-    .option("--root <path>", "repository root", ".")
-    .option("--config-file <path>", "Release Please config", "release-please-config.json")
-    .option(
-      "--manifest-file <path>",
-      "Release Please version manifest",
-      ".release-please-manifest.json",
-    )
-    .action(
-      async (options: {
-        owner?: string;
-        repo?: string;
-        targetBranch: string;
-        root: string;
-        configFile: string;
-        manifestFile: string;
-      }) => {
-        const root = resolve(options.root);
-        const repository =
-          options.owner && options.repo
-            ? { owner: options.owner, repo: options.repo }
-            : repositoryCoordinates(root);
-        const graph = JSON.parse(
-          readFileSync(resolve(root, ".projen/release-units.json"), "utf8"),
-        ) as ReleaseUnitGraph;
-        const github = await GitHub.create({
-          owner: repository.owner,
-          repo: repository.repo,
-          defaultBranch: options.targetBranch,
-          token: githubToken(),
-          ...(process.env.GITHUB_API_URL ? { apiUrl: process.env.GITHUB_API_URL } : {}),
-          ...(process.env.GITHUB_GRAPHQL_URL
-            ? {
-                graphqlUrl: process.env.GITHUB_GRAPHQL_URL.replace(/\/graphql\/?$/, ""),
-              }
-            : {}),
-        });
-        const result = await runReleasePlease({
-          github,
-          targetBranch: options.targetBranch,
-          graph,
-          configFile: options.configFile,
-          manifestFile: options.manifestFile,
-        });
-        logger.success("release state refreshed", {
-          releases: result.releases.length,
-          pullRequests: result.pullRequests.length,
-        });
-        writeOutput("releases_created", result.releases.length > 0);
-        writeOutput("prs_created", result.pullRequests.length > 0);
-        writeOutput("releases", result.releases);
-        writeOutput("prs", result.pullRequests);
-      },
-    )
-    .parseAsync();
-}

package/tasks/release-request.ts

@@ -1,166 +0,0 @@
-#!/usr/bin/env -S bun
-/** Commit and push a source branch for the generated release-request workflow. */
-
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import * as projectUtils from "@dbx-tools/core/project-utils";
-import { log, stringUtils } from "@dbx-tools/shared-core";
-import { Command } from "commander";
-import { selectReleaseSummary } from "./release-summary.ts";
-import { captureTaskCommand, runTaskCommand } from "../src/_task-command.ts";
-
-const logger = log.logger("projen:release-request");
-
-export interface PrepareReleaseRequestOptions {
-  readonly root: string;
-  readonly baseBranch: string;
-  readonly message?: string;
-  readonly notes?: string;
-  readonly notesFile?: string;
-  readonly push?: boolean;
-  readonly synthesize?: boolean;
-  readonly generateNotes?: (root: string, range: string) => Promise<string>;
-}
-
-/** Commit real changes, attach notes to one request commit, and push the branch. */
-export async function prepareReleaseRequest(
-  options: PrepareReleaseRequestOptions,
-): Promise<boolean> {
-  const root = resolve(options.root);
-  const branch = capture(root, ["branch", "--show-current"]);
-  if (!branch) throw new Error("Release requests require a named source branch");
-  if (options.push !== false) {
-    run(root, ["fetch", "origin", options.baseBranch]);
-  }
-  const baseRef = options.push === false ? options.baseBranch : `origin/${options.baseBranch}`;
-  if (options.synthesize !== false) {
-    runTaskCommand(root, process.execPath, ["x", "projen"]);
-  }
-  const dirty = capture(root, ["status", "--porcelain"]);
-  if (dirty) {
-    const message = options.message ?? "fix: prepare release";
-    if (!isReleasableMessage(message)) {
-      throw new Error("Release commit message must use fix, feat, or a breaking-change marker");
-    }
-    run(root, ["add", "-A"]);
-    run(root, ["commit", "-m", message]);
-  }
-  const ahead = Number(capture(root, ["rev-list", "--count", `${baseRef}..HEAD`]));
-  if (!Number.isInteger(ahead) || ahead < 1) {
-    logger.info("no changes from release base; skipping release request", {
-      branch,
-      base: options.baseBranch,
-    });
-    return false;
-  }
-  const messages = capture(root, ["log", "--format=%B%x00", `${baseRef}..HEAD`]);
-  if (!messages.split("\0").some(isReleasableMessage)) {
-    logger.info("branch has no releasable conventional commits; skipping release request", {
-      branch,
-    });
-    return false;
-  }
-  const latest = capture(root, ["log", "-1", "--format=%B"]);
-  if (/^Release-Request:\s*true$/m.test(latest)) {
-    logger.info("release request already exists at branch head; skipping", { branch });
-    return false;
-  }
-  if (branch === options.baseBranch) {
-    throw new Error(`Release requests must run from a branch other than ${options.baseBranch}`);
-  }
-
-  const customNotes = stringUtils.trimToNull(
-    options.notesFile ? readFileSync(resolve(root, options.notesFile), "utf8") : options.notes,
-  );
-  const notes =
-    customNotes ??
-    (await (options.generateNotes ?? generateRequestNotes)(root, `${baseRef}..HEAD`));
-  const notesPath = `.release-notes/requests/${branch.replace(/[^a-zA-Z0-9-]+/g, "-")}.md`;
-  const absoluteNotesPath = resolve(root, notesPath);
-  mkdirSync(dirname(absoluteNotesPath), { recursive: true });
-  writeFileSync(absoluteNotesPath, `# Release request: ${branch}\n\n${notes.trim()}\n`);
-  run(root, ["add", notesPath]);
-  run(root, [
-    "commit",
-    "-m",
-    "chore: request release",
-    "-m",
-    [
-      "Release-Request: true",
-      `Release-Source-Branch: ${branch}`,
-      `Release-Notes-Path: ${notesPath}`,
-    ].join("\n"),
-  ]);
-  if (options.push !== false) run(root, ["push", "--set-upstream", "origin", branch]);
-  logger.success("release request pushed", { branch });
-  return true;
-}
-
-/** Whether one conventional commit can produce a Release Please increment. */
-export function isReleasableMessage(message: string): boolean {
-  return (
-    /^(?:fix|feat)(?:\([^)\r\n]+\))?!?:/m.test(message) || /^BREAKING[ -]CHANGE:/m.test(message)
-  );
-}
-
-async function generateRequestNotes(root: string, range: string): Promise<string> {
-  const commits = capture(root, ["log", "--no-merges", "--format=%s%n%b", range]);
-  const files = capture(root, ["diff", "--name-status", range, "--", "."]);
-  const result = await selectReleaseSummary(
-    root,
-    [
-      "Write concise release-request notes for the reviewed changes below.",
-      "Focus on user-visible behavior and important compatibility details.",
-      "",
-      "Commits:",
-      commits,
-      "",
-      "Files:",
-      files,
-    ].join("\n"),
-  );
-  if (result?.summary.trim()) return result.summary.trim();
-  const subjects = capture(root, ["log", "--no-merges", "--format=- %s", range]);
-  return subjects || "Release source changes are ready for review.";
-}
-
-function capture(root: string, args: string[]): string {
-  return captureTaskCommand(root, "git", args, { check: true, stderr: "inherit" });
-}
-
-function run(root: string, args: string[]): void {
-  runTaskCommand(root, "git", args);
-}
-
-/** Restore option text after Projen forwards task arguments without shell quoting. */
-function optionText(values?: readonly string[]): string | undefined {
-  return values?.join(" ");
-}
-
-if (import.meta.main) {
-  await new Command()
-    .option("--base <branch>", "release target branch", "main")
-    .option("--message <message...>", "commit message for uncommitted source changes")
-    .option("--notes <notes...>", "custom release notes")
-    .option("--notes-file <path>", "read custom release notes from a file")
-    .action(
-      async (options: {
-        base: string;
-        message?: string[];
-        notes?: string[];
-        notesFile?: string;
-      }) => {
-        if (options.notes && options.notesFile) {
-          throw new Error("Use --notes or --notes-file, not both");
-        }
-        await prepareReleaseRequest({
-          root: projectUtils.root() ?? process.cwd(),
-          baseBranch: options.base,
-          message: optionText(options.message),
-          notes: optionText(options.notes),
-          notesFile: options.notesFile,
-        });
-      },
-    )
-    .parseAsync();
-}

package/tasks/release-summary-units.ts

@@ -1,75 +0,0 @@
-#!/usr/bin/env -S bun
-/** Generate component-qualified release notes from an affected release plan. */
-
-import { existsSync, readFileSync, readdirSync, rmSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { log } from "@dbx-tools/shared-core";
-import { Command } from "commander";
-import { generateReleaseSummary } from "./release-summary.ts";
-import { captureTaskCommand } from "../src/_task-command.ts";
-import type { ReleaseUnitGraph } from "../src/release-catalog.ts";
-import type { ReleasePlan } from "../src/release-plan.ts";
-
-const logger = log.logger("projen:release-summary-units");
-
-if (import.meta.main) {
-  await new Command()
-    .option("--root <path>", "repository root", ".")
-    .option("--plan <path>", "affected release plan", "dist/release-plan.json")
-    .option("--from-ref <ref>", "summary base ref", "origin/main")
-    .option("--to-ref <ref>", "summary target ref", "HEAD")
-    .action(async (options: { root: string; plan: string; fromRef: string; toRef: string }) => {
-      const root = resolve(options.root);
-      const plan = JSON.parse(readFileSync(resolve(root, options.plan), "utf8")) as ReleasePlan;
-      const graph = JSON.parse(
-        readFileSync(resolve(root, ".projen/release-units.json"), "utf8"),
-      ) as ReleaseUnitGraph;
-      const request = requestNotes(root);
-      for (const planned of plan.units) {
-        const unit = graph.units.find((candidate) => candidate.id === planned.id);
-        if (!unit) throw new Error(`Release plan references unknown unit ${planned.id}`);
-        const paths = graph.projects
-          .filter((project) => project.unit === unit.id)
-          .map((project) => project.path);
-        const componentTag = `${planned.component}-v${planned.oldVersion}`;
-        const fromRef = gitCapture(root, ["rev-parse", "--verify", componentTag])
-          ? componentTag
-          : options.fromRef;
-        await generateReleaseSummary({
-          root,
-          component: planned.component,
-          version: planned.newVersion,
-          paths,
-          customSummary: request.summary,
-          outputFile: `.release-notes/final/${planned.component}-v${planned.newVersion}.md`,
-          fromRef,
-          toRef: options.toRef,
-        });
-      }
-      for (const path of request.paths) rmSync(path);
-      logger.success(`generated ${plan.units.length} component release summaries`);
-    })
-    .parseAsync();
-}
-
-function requestNotes(root: string): { summary?: string; paths: string[] } {
-  const directory = resolve(root, ".release-notes/requests");
-  if (!existsSync(directory)) return { paths: [] };
-  const paths = readdirSync(directory)
-    .filter((name) => name.endsWith(".md"))
-    .sort()
-    .map((name) => join(directory, name));
-  const summary = paths
-    .map((path) =>
-      readFileSync(path, "utf8")
-        .replace(/^# .+\n+/, "")
-        .trim(),
-    )
-    .filter(Boolean)
-    .join("\n\n");
-  return { ...(summary ? { summary } : {}), paths };
-}
-
-function gitCapture(root: string, args: string[]): string {
-  return captureTaskCommand(root, "git", args);
-}

package/tasks/stamp-python.ts

@@ -1,13 +0,0 @@
-#!/usr/bin/env -S bun
-import { Command } from "commander";
-import { stampPythonProjects } from "./publish-python.ts";
-
-const program = new Command();
-program
-  .argument("<version>", "Python package version")
-  .option("--root <path>", "Python workspace package root", "packages/py")
-  .action((version: string, options: { root: string }) => {
-    stampPythonProjects(options.root, version);
-  });
-
-await program.parseAsync();