@pob/version 1.0.1

package/src/utils/conventionalChangelogUtils.ts

@@ -0,0 +1,104 @@
+import { writeChangelogString } from "conventional-changelog-writer";
+import { parseCommits as createConventionalCommitsParser } from "conventional-commits-parser";
+import type { Commit, ParserStreamOptions } from "conventional-commits-parser";
+import type { PackageJson } from "type-fest";
+import type { ConventionalChangelogConfig } from "./conventionalCommitConfigUtils.ts";
+import type { Workspace } from "./packageUtils.ts";
+
+export interface WhatBump {
+  level: 0 | 1 | 2;
+  reason: string;
+}
+export type WhatBumpResult = WhatBump | null | undefined;
+export interface BumperRecommendation extends WhatBump {
+  releaseType: "major" | "minor" | "patch";
+  commits: Commit[];
+}
+export interface EmptyBumperRecommendation {
+  commits: Commit[];
+}
+export type BumperRecommendationResult =
+  | BumperRecommendation
+  | EmptyBumperRecommendation;
+
+export interface Preset {
+  whatBump: (commits: Commit[]) => Promise<WhatBumpResult> | WhatBumpResult;
+  tags?: unknown;
+  commits?: unknown;
+  parser?: ParserStreamOptions;
+}
+
+const versions: BumperRecommendation["releaseType"][] = [
+  "major",
+  "minor",
+  "patch",
+];
+
+export const recommendBump = async (
+  commits: Parameters<ConventionalChangelogConfig["whatBump"]>[0],
+  config: ConventionalChangelogConfig,
+): Promise<Partial<BumperRecommendation>> => {
+  const whatBump = config.whatBump;
+  if (!whatBump) {
+    throw new Error("whatBump method is missing in config");
+  }
+  const result = { ...(await whatBump(commits)) };
+
+  return {
+    ...result,
+    releaseType: result.level != null ? versions[result.level] : undefined,
+  };
+};
+
+export type Commits = Parameters<ConventionalChangelogConfig["whatBump"]>[0];
+
+export const generateChangelog = (
+  workspace: Workspace,
+  pkg: PackageJson,
+  config: ConventionalChangelogConfig,
+  previousTag: string | null,
+  newTag: string | null,
+  commits: Commits | undefined,
+  date: string,
+  // eslint-disable-next-line @typescript-eslint/max-params
+): Promise<string> => {
+  if (!newTag) {
+    throw new Error(`Missing new tag for package "${pkg.name ?? ""}"`);
+  }
+
+  const originUrl =
+    typeof pkg.repository === "string" ? pkg.repository : pkg.repository?.url;
+  const match =
+    originUrl &&
+    typeof originUrl === "string" &&
+    /^(?:git@|https?:\/\/)(?:([^./:]+(?:\.com)?)[/:])?([^/:]+)\/([^./:]+)(?:.git)?/.exec(
+      originUrl,
+    );
+  const [, gitHost, gitAccount, repoName] = match || [
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+  ];
+
+  return writeChangelogString(
+    commits ?? [],
+    {
+      // @ts-expect-error - missing types
+      previousTag,
+      currentTag: newTag,
+      linkCompare: previousTag != null,
+      version: pkg.version,
+      host: gitHost ? `https://${gitHost}` : undefined,
+      owner: gitAccount,
+      repository: repoName,
+      date,
+    },
+    // @ts-expect-error - missing types
+    config.writer,
+  );
+};
+
+export const createCommitsParser = (config: ConventionalChangelogConfig) => {
+  return createConventionalCommitsParser(config.parser);
+};

package/src/utils/conventionalCommitConfigUtils.ts

@@ -0,0 +1,20 @@
+// eslint-disable-next-line import/no-unresolved
+import { loadPreset } from "conventional-changelog-preset-loader";
+import { UsageError } from "./UsageError.ts";
+import type { Preset } from "./conventionalChangelogUtils.ts";
+import type { Workspace } from "./packageUtils.ts";
+
+export type ConventionalChangelogConfig = Preset;
+
+export const loadConventionalCommitConfig = async (
+  rootWorkspace: Workspace,
+  preset: string,
+): Promise<ConventionalChangelogConfig> => {
+  try {
+    return await loadPreset<ConventionalChangelogConfig>(preset);
+  } catch (error: any) {
+    throw new UsageError(
+      `Failed to require preset "${preset}": ${error.message as string}`,
+    );
+  }
+};

package/src/utils/execCommand.ts

@@ -0,0 +1,214 @@
+import childProcess from "node:child_process";
+import type { Workspace } from "./packageUtils.ts";
+
+interface ExecResultIfFailed {
+  code: number | null;
+  signal: string | null;
+  stdout: string;
+  stderr: string;
+}
+
+interface ExecResultIfSuccess {
+  code: null;
+  signal: null;
+  stdout: string;
+  stderr: string;
+}
+
+type ExecResult<Strict extends boolean> = Strict extends true
+  ? ExecResultIfSuccess
+  : ExecResultIfFailed;
+
+async function execvp<const Strict extends boolean>(
+  command: string,
+  args: string[],
+  {
+    cwd = process.cwd(),
+    env = process.env,
+    encoding,
+    strict,
+    stdo = "pipe",
+    input,
+  }: {
+    cwd?: string;
+    env?: typeof process.env;
+    encoding?: BufferEncoding;
+    strict?: Strict;
+    stdo?: "inherit" | "pipe";
+    input?: string;
+  },
+): Promise<ExecResult<Strict>> {
+  const stdoutChunks: Uint8Array[] = [];
+  const stderrChunks: Uint8Array[] = [];
+  if (env.PWD !== undefined) {
+    env = { ...env, PWD: cwd };
+  }
+  const subprocess = childProcess.spawn(command, args, {
+    cwd,
+    env,
+    stdio: [input ? "pipe" : "ignore", stdo, stdo],
+  });
+  if (input && subprocess.stdin) {
+    // write input to stdin and close it
+    subprocess.stdin.write(input);
+    subprocess.stdin.end();
+  }
+  subprocess.stdout?.on("data", (chunk) => {
+    stdoutChunks.push(chunk);
+  });
+  subprocess.stderr?.on("data", (chunk) => {
+    stderrChunks.push(chunk);
+  });
+  return new Promise((resolve, reject) => {
+    subprocess.on("error", (err) => {
+      reject(new Error(`Process ${command} failed to spawn`));
+    });
+    subprocess.on("close", (code, signal) => {
+      const chunksToString = (chunks: Uint8Array[]): string =>
+        stdo === "inherit"
+          ? ""
+          : Buffer.concat(chunks).toString(encoding ?? "utf8");
+      const stdout = chunksToString(stdoutChunks);
+      const stderr = chunksToString(stderrChunks);
+      if (code === 0 || !strict) {
+        resolve({
+          code,
+          signal,
+          stdout,
+          stderr,
+        } as ExecResult<Strict>);
+      } else {
+        reject(
+          new Error(
+            `Process ${[command, ...args].join(" ")} exited ${code !== null ? `with code ${code}` : `with signal ${signal || ""}`}:\nstdout: ${stdout}\nstderr: ${stderr}`,
+          ),
+        );
+      }
+    });
+  });
+}
+
+async function* spawnStreamStdout<const Strict extends boolean>(
+  command: string,
+  args: string[],
+  {
+    cwd = process.cwd(),
+    env = process.env,
+    encoding,
+    strict,
+    separator,
+  }: {
+    cwd?: string;
+    env?: typeof process.env;
+    encoding?: BufferEncoding;
+    strict?: Strict;
+    separator: string;
+  },
+): AsyncGenerator<string, ExecResult<Strict>, unknown> {
+  const stderrChunks: Uint8Array[] = [];
+  if (env.PWD !== undefined) {
+    env = { ...env, PWD: cwd };
+  }
+  const subprocess = childProcess.spawn(command, args, {
+    cwd,
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+
+  subprocess.stderr.on("data", (chunk) => {
+    stderrChunks.push(chunk);
+  });
+
+  let chunk: Buffer;
+  let payload: string[];
+  let buffer = "";
+
+  for await (chunk of subprocess.stdout) {
+    buffer += chunk.toString();
+
+    if (buffer.includes(separator)) {
+      payload = buffer.split(separator);
+      buffer = payload.pop() || "";
+
+      yield* payload;
+    }
+  }
+
+  if (buffer) {
+    yield buffer;
+  }
+
+  return new Promise((resolve, reject) => {
+    subprocess.on("error", (err) => {
+      reject(new Error(`Process ${command} failed to spawn`));
+    });
+    subprocess.on("close", (code, signal) => {
+      const chunksToString = (chunks: Uint8Array[]): string =>
+        Buffer.concat(chunks).toString(encoding ?? "utf8");
+      const stderr = chunksToString(stderrChunks);
+      if (code === 0 || !strict) {
+        resolve({
+          code,
+          signal,
+          stderr,
+        } as ExecResult<Strict>);
+      } else {
+        reject(
+          new Error(
+            `Process ${[command, ...args].join(" ")} exited ${code !== null ? `with code ${code}` : `with signal ${signal || ""}`}:\nstderr: ${stderr}`,
+          ),
+        );
+      }
+    });
+  });
+}
+
+export const execCommand = (
+  workspace: Workspace,
+  commandAndArgs: string[],
+  stdo: "inherit" | "pipe" = "pipe",
+): ReturnType<typeof execvp> => {
+  const [command, ...args] = commandAndArgs;
+  if (command === undefined) {
+    throw new Error("Command is required");
+  }
+  return execvp(command, args, {
+    cwd: workspace.cwd,
+    strict: true,
+    stdo,
+  });
+};
+
+export const execCommandWithInput = (
+  workspace: Workspace,
+  commandAndArgs: string[],
+  input: string,
+  stdo: "inherit" | "pipe" = "pipe",
+): ReturnType<typeof execvp> => {
+  const [command, ...args] = commandAndArgs;
+  if (command === undefined) {
+    throw new Error("Command is required");
+  }
+  return execvp(command, args, {
+    cwd: workspace.cwd,
+    strict: true,
+    stdo,
+    input,
+  });
+};
+
+export const execCommandStreamStdout = (
+  workspace: Workspace,
+  commandAndArgs: string[],
+  separator = "\n",
+): AsyncGenerator<string, ExecResult<true>, unknown> => {
+  const [command, ...args] = commandAndArgs;
+  if (command === undefined) {
+    throw new Error("Command is required");
+  }
+  return spawnStreamStdout(command, args, {
+    cwd: workspace.cwd,
+    strict: true,
+    separator,
+  });
+};

package/src/utils/generatorUtils.ts

@@ -0,0 +1,11 @@
+export async function asyncIterableToArray<T>(
+  asyncIterable: AsyncIterable<T>,
+): Promise<T[]> {
+  const result: T[] = [];
+
+  for await (const value of asyncIterable) {
+    result.push(value);
+  }
+
+  return result;
+}

package/src/utils/gitUtils.ts

@@ -0,0 +1,193 @@
+import semver from "semver";
+import { UsageError } from "./UsageError.ts";
+import { execCommand, execCommandStreamStdout } from "./execCommand.ts";
+import type { Workspace } from "./packageUtils.ts";
+
+export const getGitCurrentBranch = async (
+  workspace: Workspace,
+): Promise<string> => {
+  const { stdout } = await execCommand(workspace, [
+    "git",
+    "rev-parse",
+    "--abbrev-ref",
+    "HEAD",
+  ]);
+  const currentBranch = stdout.trim();
+
+  if (currentBranch === "HEAD") {
+    throw new UsageError("HEAD is detached. Please checkout a branch.");
+  }
+
+  return currentBranch;
+};
+
+export const createGitCommit = async (
+  workspace: Workspace,
+  commitMessage: string,
+): Promise<void> => {
+  await execCommand(workspace, ["git", "add", "-A"]);
+
+  await execCommand(workspace, [
+    "git",
+    "commit",
+    "--no-verify",
+    "-m",
+    commitMessage,
+  ]);
+};
+
+export const createGitTag = async (
+  workspace: Workspace,
+  newTag: string,
+): Promise<void> => {
+  await execCommand(workspace, ["git", "tag", newTag, "-m", newTag]);
+};
+
+export const pushCommitsAndTags = async (
+  workspace: Workspace,
+  gitRemote: string,
+  currentBranch: string,
+): Promise<void> => {
+  await execCommand(workspace, [
+    "git",
+    "push",
+    "--follow-tags",
+    "--no-verify",
+    "--atomic",
+    gitRemote,
+    currentBranch,
+  ]);
+};
+
+export const isBehindRemote = async (
+  workspace: Workspace,
+  gitRemote: string,
+  currentBranch: string,
+): Promise<boolean> => {
+  await execCommand(workspace, ["git", "remote", "update", gitRemote]);
+  const { stdout } = await execCommand(workspace, [
+    "git",
+    "rev-list",
+    "--left-right",
+    "--count",
+    `${gitRemote}/${currentBranch}..${currentBranch}`,
+  ]);
+
+  const [behind] = stdout.split("\t").map((val) => parseInt(val, 10));
+
+  return behind ? behind > 0 : false;
+};
+
+export const getDirtyFiles = async (workspace: Workspace): Promise<string> => {
+  const { stdout: dirtyFiles } = await execCommand(workspace, [
+    "git",
+    "status",
+    "--porcelain",
+  ]);
+  return dirtyFiles;
+};
+
+const toArray = <T>(input: T | T[]): T[] =>
+  Array.isArray(input) ? input : [input];
+
+export interface GitTagVersion {
+  tag: string;
+  version: string;
+}
+
+export const getGitLatestTagVersion = async (
+  workspace: Workspace,
+  {
+    prefix,
+    skipUnstable,
+    since,
+    from = "",
+    to = "HEAD",
+    path,
+  }: {
+    prefix?: string;
+    skipUnstable?: boolean;
+    since?: Date | string;
+    from?: string;
+    to?: string;
+    path?: string[] | string;
+  } = {},
+): Promise<GitTagVersion | null> => {
+  // eslint-disable-next-line regexp/no-super-linear-backtracking
+  const tagRegex = /tag:\s*(.+?)[,)]/gi;
+  for await (const chunk of execCommandStreamStdout(workspace, [
+    "git",
+    "log",
+    "--no-color",
+    "--date-order",
+    "--format=%d",
+    ...(since
+      ? [`--since=${since instanceof Date ? since.toISOString() : since}`]
+      : []),
+    [from, to].filter(Boolean).join(".."),
+    ...(path ? ["--", ...toArray(path)] : []),
+  ])) {
+    const trimmed = chunk.trim();
+    if (!trimmed) continue;
+    const matches = trimmed.matchAll(tagRegex);
+    for (const match of matches) {
+      const tag = match[1];
+      if (!tag) continue;
+      if (prefix && !tag.startsWith(prefix)) {
+        continue;
+      }
+      const version = prefix ? tag.slice(prefix.length) : tag;
+      if (!semver.valid(version)) {
+        continue;
+      }
+      if (skipUnstable && semver.prerelease(version)) {
+        continue;
+      }
+      return { tag, version };
+    }
+  }
+
+  return null;
+};
+
+const GIT_COMMIT_SEPARATOR =
+  "------------------------ >8 ------------------------";
+
+export const getGitCommits = (
+  workspace: Workspace,
+  {
+    path,
+    from = "",
+    to = "HEAD",
+    format = "%B",
+    reverse,
+    merges,
+    since,
+  }: {
+    format?: string;
+    path?: string[] | string;
+    from?: string;
+    to?: string;
+    reverse?: boolean;
+    merges?: boolean;
+    since?: Date | string;
+  } = {},
+) => {
+  return execCommandStreamStdout(
+    workspace,
+    [
+      "git",
+      "log",
+      `--format=${format}%n${GIT_COMMIT_SEPARATOR}`,
+      ...(since
+        ? [`--since=${since instanceof Date ? since.toISOString() : since}`]
+        : []),
+      ...(reverse ? ["--reverse"] : []),
+      ...(merges ? ["--merges"] : []),
+      ...(merges === false ? ["--no-merges"] : []),
+      [from, to].filter(Boolean).join(".."),
+      ...(path ? ["--", ...toArray(path)] : []),
+    ],
+    GIT_COMMIT_SEPARATOR,
+  );
+};

package/src/utils/githubUtils.ts

@@ -0,0 +1,114 @@
+import { UsageError } from "./UsageError.ts";
+import { execCommandWithInput } from "./execCommand.ts";
+import type { Workspace } from "./packageUtils.ts";
+
+export async function ensureGhCliAvailable(
+  workspace: Workspace,
+): Promise<void> {
+  const { GH_TOKEN } = process.env;
+
+  if (!GH_TOKEN) {
+    throw new UsageError('"GH_TOKEN" environment variable required');
+  }
+
+  try {
+    // Use existing execCommand helper pattern by spawning gh --version
+    // We import execCommand lazily to avoid cycles when utils are used elsewhere
+    const { execCommand } = await import("./execCommand.ts");
+    await execCommand(workspace, ["gh", "--version"]);
+  } catch {
+    throw new UsageError(
+      'The "gh" CLI is required. Please install GitHub CLI: https://cli.github.com/',
+    );
+  }
+}
+
+interface ParsedGithubUrl {
+  username: string;
+  reponame: string;
+}
+
+const githubRegex = /^https?:\/\/github.com\/([^#/]+)\/([^#/]+?)(?:\.git)?$/;
+export const parseGithubRepoUrl = (workspace: Workspace): ParsedGithubUrl => {
+  const repository = workspace.pkg.repository;
+
+  const url: string | undefined =
+    typeof repository === "string" ? repository : repository?.url;
+
+  if (!url) {
+    throw new Error(
+      "No repository URL found in manifest. Please add one and try again. https://docs.npmjs.com/cli/v9/configuring-npm/package-json#repository",
+    );
+  }
+  const match = githubRegex.exec(url);
+
+  if (!match) {
+    throw new Error(`Invalid GitHub repository URL: "${url}"`);
+  }
+  const [, username, reponame] = match;
+  if (!username || !reponame) {
+    throw new Error(`Invalid GitHub repository URL: "${url}"`);
+  }
+  return { username, reponame };
+};
+
+const extractHostnameFromGheApiUrl = (gheApiUrl: string): string | null => {
+  try {
+    const url = new URL(gheApiUrl);
+    return url.hostname || null;
+  } catch {
+    // fallback: try to strip protocol and path
+    const m = /^https?:\/\/([^/]+)/.exec(gheApiUrl);
+    return m?.[1] || null;
+  }
+};
+
+export const createGhRelease = async (
+  workspace: Workspace,
+  opts: {
+    parsedRepoUrl: ParsedGithubUrl;
+    tag: string;
+    body: string;
+    prerelease: boolean;
+  },
+): Promise<void> => {
+  const { parsedRepoUrl, tag, body, prerelease } = opts;
+
+  const { GH_TOKEN, GHE_API_URL } = process.env;
+
+  if (!GH_TOKEN) {
+    await ensureGhCliAvailable(workspace);
+    return;
+  }
+
+  // Determine hostname for GHE if provided
+  const args: string[] = [
+    "release",
+    "create",
+    tag,
+    "--repo",
+    `${parsedRepoUrl.username}/${parsedRepoUrl.reponame}`,
+    "--notes",
+    "-",
+  ];
+
+  if (prerelease) {
+    args.push("--prerelease");
+  }
+
+  if (GHE_API_URL) {
+    const hostname = extractHostnameFromGheApiUrl(GHE_API_URL);
+    if (hostname) {
+      args.push("--hostname", hostname);
+    }
+  }
+
+  try {
+    await execCommandWithInput(workspace, ["gh", ...args], body);
+  } catch (error) {
+    // execCommandWithInput will include stdout/stderr in its error message when strict
+    throw new Error(
+      `gh release create failed: ${String(error instanceof Error ? error.message : error)}`,
+    );
+  }
+};

package/src/utils/mapUtils.ts

@@ -0,0 +1,7 @@
+export function getMapArrayItemForKey<K, V>(map: Map<K, V[]>, key: K): V[] {
+  let value: V[] | undefined = map.get(key);
+  if (value === undefined) {
+    map.set(key, (value = [] as V[]));
+  }
+  return value;
+}