index.ts

import { Context, Probot } from "probot";
import { parse, query } from "kdljs";
import micromatch from "micromatch";
import path from "path";
import semver from "semver";

interface PackageVersions {
  [path: string]: {
    version: string;
    changesets: Changesets;
  };
}

interface Changesets {
  added?: string[];
  changed?: string[];
  deprecated?: string[];
  removed?: string[];
  fixed?: string[];
  security?: string[];
}

interface ChangesetNode {
  name: "major" | "minor" | "patch";
  values: string[];
  properties: {
    type: "added" | "changed" | "deprecated" | "removed" | "fixed" | "security";
    package?: string;
  };
}

export default (app: Probot) => {
  // create issue if nanpa changesets exist
  app.on("push", async (context) => {
    const repo = context.repo();
    const botLogin = (
      await context.octokit.apps.getInstallation({
        installation_id: context.payload.installation!.id,
      })
    ).data.app_slug;
    const baseBranch = (
      await context.octokit.repos.get({
        owner: repo.owner,
        repo: repo.repo,
      })
    ).data.default_branch;
    if (context.payload.ref === "refs/heads/" + baseBranch) {
      await setBody(context, repo, botLogin, undefined);
    }
  });

  app.on("issue_comment.created", async (context) => {
    const repo = context.repo();
    const botLogin = (
      await context.octokit.apps.getInstallation({
        installation_id: context.payload.installation!.id,
      })
    ).data.app_slug;

    if (
      context.payload.issue.user.login == botLogin + "[bot]" &&
      context.payload.comment.user.login !== botLogin + "[bot]"
    ) {
      try {
        // Get existing defined prereleases
        const prereleases = JSON.parse(
          context.payload.issue.body!.match(
            /<!-- ilo-prereleases: (.*) -->/,
          )![1],
        );

        const messages: string[] = [];

        // Get all lines from comment
        const lines = context.payload.comment.body.split("\n");
        lines.forEach((line) => {
          const preHeader = /^ilo prerelease ([\d\w/_-]+)( [\d\w_-]+)?$/.exec(
            line,
          );
          if (preHeader) {
            if (preHeader[2]) {
              preHeader[2] = preHeader[2].trim();
              prereleases[preHeader[1]] = preHeader[2];
              messages.push(
                `Prerelease mode set to \`${preHeader[2]}\` for package ${preHeader[1]}.`,
              );
            } else {
              delete prereleases[preHeader[1]];
              messages.push(
                `Prerelease mode disabled for package ${preHeader[1]}.`,
              );
            }
          }
        });

        await setBody(context, repo, botLogin, prereleases);

        // Comment changes
        await context.octokit.issues.createComment({
          owner: repo.owner,
          repo: repo.repo,
          issue_number: context.payload.issue.number,
          body: messages.join("\n"),
        });
      } catch (error) {
        console.error(error);
      }
    }
  });

  app.on("issues.closed", async (context) => {
    const botLogin = (
      await context.octokit.apps.getInstallation({
        installation_id: context.payload.installation!.id,
      })
    ).data.app_slug;

    if (context.payload.issue.user.login == botLogin + "[bot]") {
      try {
        // Fetch the workflow id from the repository secrets
        const repo = context.repo();
        const workflow_id = await context.octokit.actions
          .getRepoVariable({
            owner: repo.owner,
            repo: repo.repo,
            name: "NANPA_WORKFLOW",
          })
          .then((value) => value.data.value);
        if (workflow_id == "") {
          context.log.error("NANPA_WORKFLOW secret is not set");
          return;
        }

        // get packages to update
        const packages = [
          ...context.payload.issue.body!.matchAll(/- \[x\] ([^\n ]+)\n?/g),
        ]
          .map((x) => x.slice(1))
          .flat();
        if (packages.length == 0) return;
        const inputs = {
          packages: JSON.stringify(packages),
        };

        await context.octokit.actions.createWorkflowDispatch({
          owner: context.payload.repository.owner.login,
          repo: context.payload.repository.name,
          workflow_id,
          ref: context.payload.repository.default_branch,
          inputs,
        });
      } catch (error) {
        console.error(error);
      }
    }
  });

  app.on("pull_request.opened", async (context) => {
    try {
      const repo = context.repo();
      const diff = await context.octokit.repos
        .compareCommitsWithBasehead({
          owner: repo.owner,
          repo: repo.repo,
          basehead: `${(context.payload.pull_request as any).base.sha}...${(context.payload.pull_request as any).head.sha}`,
        })
        .then((payload) => payload.data);
      if (
        diff.files &&
        diff.files.some(
          (file) => file.filename.endsWith(".kdl") && file.status === "added",
        )
      ) {
        return;
      }

      const body = `it seems like you haven't added any nanpa changeset files to this PR.

if this pull request includes changes to code, make sure to add a changeset, by writing a file to \`.nanpa/<unique-name>.kdl\`:

\`\`\`
minor type="added" "Introduce frobnication algorithm"
\`\`\`

refer to [the manpage](https://github.com/nbsp/nanpa/blob/master/doc/nanpa-changeset.5.scd) for more information.`;

      await context.octokit.issues.createComment({
        owner: repo.owner,
        repo: repo.repo,
        issue_number: (context.payload.pull_request as any).number,
        body,
      });
    } catch (error) {
      console.error(error)
    }
  });
};

async function setBody(
  context: Context,
  repo: { repo: never; owner: never },
  botLogin: string,
  prereleases?: { [id: string]: string },
) {
  try {
    const glob = "**/.nanparc";
    const baseBranch = (
      await context.octokit.repos.get({
        owner: repo.owner,
        repo: repo.repo,
      })
    ).data.default_branch;

    // show open issues by bot
    const openIssues = await context.octokit.issues.listForRepo({
      owner: repo.owner,
      repo: repo.repo,
      state: "open",
      creator: botLogin + "[bot]",
    });
    if (prereleases === undefined) {
      if (openIssues.data.length > 0) {
        // get existing defined prereleases
        prereleases = JSON.parse(
          await context.octokit.issues
            .get({
              owner: repo.owner,
              repo: repo.repo,
              issue_number: openIssues.data[0].number,
            })
            .then(
              (issue) =>
                issue.data.body!.match(/<!-- ilo-prereleases: (.*) -->/)![1],
            ),
        );
      } else {
        prereleases = {};
      }
    }

    // list files
    const tree = await context.octokit.git.getTree({
      owner: repo.owner,
      repo: repo.repo,
      tree_sha: baseBranch,
      recursive: "true",
    });

    // get all nanpa-defined projects
    const filePaths = tree.data.tree
      .map((file) => file.path)
      .filter((x) => typeof x == "string");
    const packages = [
      ...new Set(
        micromatch(filePaths, glob).map((filePath) => {
          if (filePath.startsWith(".nanparc")) return "";
          return filePath.slice(0, filePath.length - "/.nanparc".length);
        }),
      ),
    ];

    let srcPackages: string[];
    let superPackages: string[];
    if (packages.length === 1) {
      srcPackages = packages;
      superPackages = [];
    } else {
      // only get packages that aren't superpackages
      srcPackages = await Promise.all(
        packages.map(async (pkg) => {
          const packagePath = path.join(pkg, ".nanpa");
          const matchedFiles = tree.data.tree.filter(
            (x) =>
              x.path &&
              x.path.startsWith(packagePath) &&
              x.path.endsWith(".kdl"),
          );

          // no local changesets
          if (matchedFiles.length === 0) return pkg;

          return (await matchedFiles.reduce(async (acc, file) => {
            if (await acc) return true;
            const content = await context.octokit.repos
              .getContent({
                owner: repo.owner,
                repo: repo.repo,
                tree_sha: baseBranch,
                path: file.path!,
              })
              .then((result) => {
                if (!("content" in result.data)) throw new Error();
                return result.data.content;
              })
              .then((result) => Buffer.from(result, "base64").toString())
              .then((content) => parse(content).output!);

            return query(content, "[prop(package)]").length > 0;
          }, Promise.resolve(false)))
            ? null
            : pkg;
        }),
      ).then((pkgs) => pkgs.filter((x): x is string => !!x));
      superPackages = packages.filter((pkg) => !(pkg in srcPackages));
    }

    const updates = await srcPackages.reduce(
      async (accPromise: Promise<PackageVersions>, pkg) => {
        const acc = await accPromise;
        let bump = 0;
        const changesets: Changesets = {};

        let version = /(?<=version +)[^\n ]+(?= *\n?)/.exec(
          await context.octokit.repos
            .getContent({
              owner: repo.owner,
              repo: repo.repo,
              tree_sha: baseBranch,
              path: path.join(pkg, ".nanparc"),
            })
            .then((result) => {
              if (!("content" in result.data)) throw new Error();
              return result.data.content;
            })
            .then((result) => Buffer.from(result, "base64").toString()),
        )![0];

        // get changesets from inside package
        const packagePath = path.join(pkg, ".nanpa");
        const matchedFiles = tree.data.tree.filter(
          (x) =>
            x.path && x.path.startsWith(packagePath) && x.path.endsWith(".kdl"),
        );

        for (const file of matchedFiles) {
          const content = await context.octokit.repos
            .getContent({
              owner: repo.owner,
              repo: repo.repo,
              tree_sha: baseBranch,
              path: file.path!,
            })
            .then((result) => {
              if (!("content" in result.data)) throw new Error();
              return result.data.content;
            })
            .then((result) => Buffer.from(result, "base64").toString())
            .then((content) => parse(content).output!);

          for (const node of query(content, "top()")[0]
            .children as ChangesetNode[]) {
            switch (node.name) {
              case "major":
                bump = 3;
                break;
              case "minor":
                if (bump < 2) bump = 2;
                break;
              case "patch":
                if (bump < 1) bump = 1;
                break;
            }

            switch (node.properties.type) {
              case "added":
                if (!changesets.added) changesets.added = [];
                changesets.added.push(node.values[0]);
                break;
              case "changed":
                if (!changesets.changed) changesets.changed = [];
                changesets.changed.push(node.values[0]);
                break;
              case "deprecated":
                if (!changesets.deprecated) changesets.deprecated = [];
                changesets.deprecated.push(node.values[0]);
                break;
              case "removed":
                if (!changesets.removed) changesets.removed = [];
                changesets.removed.push(node.values[0]);
                break;
              case "fixed":
                if (!changesets.fixed) changesets.fixed = [];
                changesets.fixed.push(node.values[0]);
                break;
              case "security":
                if (!changesets.security) changesets.security = [];
                changesets.security.push(node.values[0]);
                break;
            }
          }
        }

        // get changesets from superpackages
        for (const spkg of superPackages) {
          const packagePath = path.join(spkg, ".nanpa");
          const matchedFiles = tree.data.tree.filter(
            (x) =>
              x.path &&
              x.path.startsWith(packagePath) &&
              x.path.endsWith(".kdl"),
          );
          for (const file of matchedFiles) {
            const content = await context.octokit.repos
              .getContent({
                owner: repo.owner,
                repo: repo.repo,
                tree_sha: baseBranch,
                path: file.path!,
              })
              .then((result) => {
                if (!("content" in result.data)) throw new Error();
                return result.data.content;
              })
              .then((result) => Buffer.from(result, "base64").toString())
              .then((content) => parse(content).output!);

            for await (const node of query(content, "top()")[0]
              .children as ChangesetNode[]) {
              if (
                !node.properties.package ||
                path.join(spkg, node.properties.package) !== pkg
              ) {
                continue;
              }
              switch (node.name) {
                case "major":
                  bump = 3;
                  break;
                case "minor":
                  if (bump < 2) bump = 2;
                  break;
                case "patch":
                  if (bump < 1) bump = 1;
                  break;
              }

              switch (node.properties.type) {
                case "added":
                  if (!changesets.added) changesets.added = [];
                  changesets.added.push(node.values[0]);
                  break;
                case "changed":
                  if (!changesets.changed) changesets.changed = [];
                  changesets.changed.push(node.values[0]);
                  break;
                case "deprecated":
                  if (!changesets.deprecated) changesets.deprecated = [];
                  changesets.deprecated.push(node.values[0]);
                  break;
                case "removed":
                  if (!changesets.removed) changesets.removed = [];
                  changesets.removed.push(node.values[0]);
                  break;
                case "fixed":
                  if (!changesets.fixed) changesets.fixed = [];
                  changesets.fixed.push(node.values[0]);
                  break;
                case "security":
                  if (!changesets.security) changesets.security = [];
                  changesets.security.push(node.values[0]);
                  break;
              }
            }
          }
        }

        const pkgName = `${repo.repo}${pkg === "" ? "" : `/${pkg}`}`;

        // special flag that allows bumping prereleases even without changesets.
        // 0.2.0-alpha.2 can be bumped to 0.2.0, or 0.2.0-beta.0, but *not* 0.2.0-alpha.3.
        let bumpPre = false;

        // bump version
        switch (bump) {
          case 0:
            if (semver.prerelease(version)) {
              if (prereleases && prereleases[pkgName]) {
                if (semver.prerelease(version)![0] !== prereleases[pkgName]) {
                  bumpPre = true;
                  version = semver.inc(
                    version,
                    "prerelease",
                    prereleases[pkgName],
                  )!;
                }
              } else {
                bumpPre = true;
                version = semver.inc(version, "patch")!;
              }
            }
            break;
          case 1:
            if (prereleases && prereleases[pkgName]) {
              version = semver.inc(
                version,
                "prerelease",
                prereleases[pkgName],
              )!;
            } else {
              version = semver.inc(version, "patch")!;
            }
            break;
          case 2:
            if (prereleases && prereleases[pkgName]) {
              if (semver.prerelease(version) && semver.patch(version) === 0) {
                version = semver.inc(
                  version,
                  "prerelease",
                  prereleases[pkgName],
                )!;
              } else {
                version = semver.inc(
                  version,
                  "preminor",
                  prereleases[pkgName],
                )!;
              }
            } else {
              version = semver.inc(version, "minor")!;
            }
            break;
          case 3:
            if (prereleases && prereleases[pkgName]) {
              if (
                semver.prerelease(version) &&
                semver.minor(version) === 0 &&
                semver.patch(version) === 0
              ) {
                version = semver.inc(
                  version,
                  "prerelease",
                  prereleases[pkgName],
                )!;
              } else {
                version = semver.inc(
                  version,
                  "premajor",
                  prereleases[pkgName],
                )!;
              }
            } else {
              version = semver.inc(version, "major")!;
            }
            break;
        }

        if (
          !changesets.added &&
          !changesets.changed &&
          !changesets.deprecated &&
          !changesets.fixed &&
          !changesets.removed &&
          !changesets.security &&
          !bumpPre
        ) {
          return acc;
        }

        acc[pkgName] = {
          version,
          changesets,
        };
        return acc;
      },
      Promise.resolve({}),
    );

    let title = `bump: ${Object.keys(updates).join(", ")}`;

    let body =
      `<!-- ilo-prereleases: ${JSON.stringify(prereleases)} -->\n` +
      "ilo has detected nanpa changesets files and/or prereleased packages in this repository.\n" +
      `choose which packages you wish to update from the checkboxes below, and close this issue to start a CI build on \`${baseBranch}\`.\n` +
      "for more information, refer to the [nanpa](https://github.com/nbsp/nanpa) and [ilo](https://github.com/nbsp/ilo) repositories.\n\n";

    Object.entries(updates).forEach((update) => {
      const [name, { version, changesets }] = update;
      body += `## ${name}@${version}\n\n`;

      if (changesets.added) {
        body += "### Added\n\n";
        changesets.added.forEach((changeset) => (body += `- ${changeset}\n`));
      }
      if (changesets.changed) {
        body += "### Changed\n\n";
        changesets.changed.forEach((changeset) => (body += `- ${changeset}\n`));
      }
      if (changesets.deprecated) {
        body += "### Deprecated\n\n";
        changesets.deprecated.forEach(
          (changeset) => (body += `- ${changeset}\n`),
        );
      }
      if (changesets.fixed) {
        body += "### Fixed\n\n";
        changesets.fixed.forEach((changeset) => (body += `- ${changeset}\n`));
      }
      if (changesets.removed) {
        body += "### Removed\n\n";
        changesets.removed.forEach((changeset) => (body += `- ${changeset}\n`));
      }
      if (changesets.security) {
        body += "### Security\n\n";
        changesets.security.forEach(
          (changeset) => (body += `- ${changeset}\n`),
        );
      }
    });

    body += "# Packages to update\n";
    Object.entries(updates).forEach((update) => {
      const [name, { version }] = update;
      body += `- [x] ${name}@${version}\n`;
    });

    if (Object.entries(updates).length == 0) {
      title = "bump: nothing staged";
      body =
        "<!-- ilo-prereleases: {} -->\n" +
        "ilo could not detect nanpa changesets files in this repository. when you add some, you'll see them here.\n" +
        "for more information, refer to the [nanpa](https://github.com/nbsp/nanpa) and [ilo](https://github.com/nbsp/ilo) repositories.";
    }

    if (openIssues.data.length > 0) {
      await context.octokit.issues.update({
        owner: repo.owner,
        repo: repo.repo,
        issue_number: openIssues.data[0].number,
        title,
        body,
      });
    } else {
      if (Object.entries(updates).length > 0) {
        await context.octokit.issues.create({
          owner: repo.owner,
          repo: repo.repo,
          title,
          body,
        });
      }
    }
  } catch (error) {
    console.error(error);
  }
}