bunset 0.0.2

package/src/index.ts

@@ -0,0 +1,197 @@
+#!/usr/bin/env bun
+
+import { resolveOptions } from "./cli.ts";
+import { loadConfig } from "./config.ts";
+import {
+  parseCommit,
+  groupCommits,
+  filterCommitsForPackage,
+} from "./commits.ts";
+import { buildChangelogEntry, writeChangelog } from "./changelog.ts";
+import {
+  getLastTag,
+  getCommitsSince,
+  getCommitFiles,
+  commitAndTag,
+} from "./git.ts";
+import { getUpdatedDependencies } from "./deps.ts";
+import {
+  isWorkspace,
+  getAllPackages,
+  getChangedPackages,
+} from "./workspace.ts";
+import { bumpVersion, updatePackageVersion } from "./version.ts";
+import type { ParsedCommit, GroupedCommits } from "./types.ts";
+
+const cwd = process.cwd();
+
+const isWs = await isWorkspace(cwd);
+const config = await loadConfig(cwd);
+const options = await resolveOptions(isWs, config);
+
+const allPackages = await getAllPackages(cwd);
+const lastTag = await getLastTag(cwd);
+const rawCommits = await getCommitsSince(cwd, lastTag);
+
+if (rawCommits.length === 0) {
+  console.log("No commits found since last tag. Nothing to do.");
+  process.exit(0);
+}
+
+const parsed = rawCommits.map((c) => parseCommit(c.hash, c.message));
+
+// In a monorepo with filtering, fetch the file list for each commit
+const shouldFilter = isWs && options.filterByPackage;
+if (shouldFilter) {
+  await Promise.all(
+    parsed.map(async (commit) => {
+      commit.files = await getCommitFiles(cwd, commit.hash);
+    }),
+  );
+}
+
+const globalGroups = groupCommits(parsed);
+
+if (options.sections.every((type) => globalGroups[type].length === 0)) {
+  console.log("No categorized commits found. Nothing to do.");
+  process.exit(0);
+}
+
+let packages =
+  options.scope === "changed"
+    ? await getChangedPackages(cwd, allPackages, lastTag)
+    : allPackages;
+
+if (packages.length === 0) {
+  console.log("No changed packages found. Nothing to do.");
+  process.exit(0);
+}
+
+function getPackageGroups(
+  pkg: (typeof packages)[number],
+  allParsed: ParsedCommit[],
+): GroupedCommits {
+  if (!shouldFilter) return globalGroups;
+  const filtered = filterCommitsForPackage(allParsed, pkg.path, cwd);
+  return groupCommits(filtered);
+}
+
+function packageHasChanges(groups: GroupedCommits): boolean {
+  return options.sections.some((type) => groups[type].length > 0);
+}
+
+if (options.dryRun) {
+  console.log("--- Dry Run ---\n");
+
+  const tags: string[] = [];
+
+  for (const pkg of packages) {
+    const groups = getPackageGroups(pkg, parsed);
+    const hasChanges = packageHasChanges(groups);
+
+    if (!hasChanges && options.perPackageTags) {
+      console.log(`${pkg.name}: no matching commits, skipping.`);
+      continue;
+    }
+
+    const oldVersion = pkg.version ?? "0.0.0";
+    const newVersion = bumpVersion(oldVersion, options.bump);
+    console.log(`${pkg.name}: ${oldVersion} → ${newVersion}`);
+
+    const updatedDeps = await getUpdatedDependencies(
+      cwd,
+      pkg.packageJsonPath,
+      lastTag,
+    );
+    const entry = buildChangelogEntry(
+      newVersion,
+      groups,
+      updatedDeps,
+      options.sections,
+    );
+
+    console.log(`\nChangelog entry for ${pkg.name}:`);
+    console.log(entry);
+
+    if (options.tag) {
+      if (options.perPackageTags) {
+        tags.push(`${pkg.name}@${newVersion}`);
+      } else {
+        tags.push(`${options.tagPrefix}${newVersion}`);
+      }
+    }
+  }
+
+  if (options.commit) {
+    const msg =
+      packages.length === 1
+        ? `chore: release ${packages[0]!.name}@${bumpVersion(packages[0]!.version ?? "0.0.0", options.bump)}`
+        : `chore: release ${packages.length} packages`;
+    console.log(`Would commit: ${msg}`);
+  } else {
+    console.log("Will not commit (--commit not set).");
+  }
+
+  if (tags.length > 0) {
+    console.log(`Would tag: ${tags.join(", ")}`);
+  } else if (!options.tag) {
+    console.log("Will not tag (--tag not set).");
+  }
+
+  console.log("\nNo files were modified.");
+  process.exit(0);
+}
+
+const tags: string[] = [];
+
+for (const pkg of packages) {
+  const groups = getPackageGroups(pkg, parsed);
+  const hasChanges = packageHasChanges(groups);
+
+  // per-package-tags + no changes → skip entirely
+  if (!hasChanges && options.perPackageTags) {
+    console.log(`${pkg.name}: no matching commits, skipping.`);
+    continue;
+  }
+
+  const { oldVersion, newVersion } = await updatePackageVersion(
+    pkg.packageJsonPath,
+    options.bump,
+  );
+  console.log(`${pkg.name}: ${oldVersion} → ${newVersion}`);
+
+  const updatedDeps = await getUpdatedDependencies(
+    cwd,
+    pkg.packageJsonPath,
+    lastTag,
+  );
+  const entry = buildChangelogEntry(
+    newVersion,
+    groups,
+    updatedDeps,
+    options.sections,
+  );
+  await writeChangelog(pkg.path, entry);
+
+  if (options.tag) {
+    if (options.perPackageTags) {
+      tags.push(`${pkg.name}@${newVersion}`);
+    } else {
+      tags.push(`${options.tagPrefix}${newVersion}`);
+    }
+  }
+}
+
+if (options.commit) {
+  const msg =
+    packages.length === 1
+      ? `chore: release ${packages[0]!.name}@${(await Bun.file(packages[0]!.packageJsonPath).json()).version}`
+      : `chore: release ${packages.length} packages`;
+  await commitAndTag(cwd, msg, options.tag ? tags : []);
+  console.log(`Committed: ${msg}`);
+  if (tags.length > 0) {
+    console.log(`Tagged: ${tags.join(", ")}`);
+  }
+}
+
+console.log("Done.");

package/src/types.ts

@@ -0,0 +1,50 @@
+export type BumpType = "patch" | "minor" | "major";
+export type PackageScope = "all" | "changed";
+export type CommitType =
+  | "feature"
+  | "bugfix"
+  | "refactor"
+  | "perf"
+  | "style"
+  | "test"
+  | "docs"
+  | "build"
+  | "ops"
+  | "chore";
+
+export interface CliOptions {
+  scope: PackageScope;
+  bump: BumpType;
+  commit: boolean;
+  tag: boolean;
+  perPackageTags: boolean;
+  sections: CommitType[];
+  dryRun: boolean;
+  filterByPackage: boolean;
+  tagPrefix: string;
+}
+
+export interface ParsedCommit {
+  hash: string;
+  message: string;
+  type: CommitType | null;
+  commitScope: string | null;
+  description: string;
+  files: string[];
+}
+
+export type GroupedCommits = Record<CommitType, ParsedCommit[]>;
+
+export interface PackageInfo {
+  name: string;
+  path: string;
+  packageJsonPath: string;
+  version: string;
+  dependencies: Record<string, string>;
+  devDependencies: Record<string, string>;
+}
+
+export interface UpdatedDependency {
+  name: string;
+  newVersion: string;
+}

package/src/version.test.ts

@@ -0,0 +1,40 @@
+import { test, expect, describe } from "bun:test";
+import { parseSemver, bumpVersion } from "./version.ts";
+
+describe("parseSemver", () => {
+  test("parses standard semver", () => {
+    expect(parseSemver("1.2.3")).toEqual([1, 2, 3]);
+  });
+
+  test("strips leading v", () => {
+    expect(parseSemver("v2.0.1")).toEqual([2, 0, 1]);
+  });
+
+  test("handles 0.0.0", () => {
+    expect(parseSemver("0.0.0")).toEqual([0, 0, 0]);
+  });
+});
+
+describe("bumpVersion", () => {
+  test("bumps patch", () => {
+    expect(bumpVersion("1.2.3", "patch")).toBe("1.2.4");
+  });
+
+  test("bumps minor and resets patch", () => {
+    expect(bumpVersion("1.2.3", "minor")).toBe("1.3.0");
+  });
+
+  test("bumps major and resets minor/patch", () => {
+    expect(bumpVersion("1.2.3", "major")).toBe("2.0.0");
+  });
+
+  test("bumps from 0.0.0", () => {
+    expect(bumpVersion("0.0.0", "patch")).toBe("0.0.1");
+    expect(bumpVersion("0.0.0", "minor")).toBe("0.1.0");
+    expect(bumpVersion("0.0.0", "major")).toBe("1.0.0");
+  });
+
+  test("handles v prefix", () => {
+    expect(bumpVersion("v1.0.0", "patch")).toBe("1.0.1");
+  });
+});

package/src/version.ts

@@ -0,0 +1,32 @@
+import type { BumpType } from "./types.ts";
+
+export function parseSemver(version: string): [number, number, number] {
+  const clean = version.startsWith("v") ? version.slice(1) : version;
+  const [major, minor, patch] = clean.split(".").map(Number);
+  return [major ?? 0, minor ?? 0, patch ?? 0];
+}
+
+export function bumpVersion(current: string, bump: BumpType): string {
+  const [major, minor, patch] = parseSemver(current);
+  switch (bump) {
+    case "major":
+      return `${major + 1}.0.0`;
+    case "minor":
+      return `${major}.${minor + 1}.0`;
+    case "patch":
+      return `${major}.${minor}.${patch + 1}`;
+  }
+}
+
+export async function updatePackageVersion(
+  packageJsonPath: string,
+  bump: BumpType,
+): Promise<{ oldVersion: string; newVersion: string }> {
+  const file = Bun.file(packageJsonPath);
+  const pkg = await file.json();
+  const oldVersion = pkg.version ?? "0.0.0";
+  const newVersion = bumpVersion(oldVersion, bump);
+  pkg.version = newVersion;
+  await Bun.write(packageJsonPath, JSON.stringify(pkg, null, 2) + "\n");
+  return { oldVersion, newVersion };
+}

package/src/workspace.ts

@@ -0,0 +1,68 @@
+import { $ } from "bun";
+import { join } from "node:path";
+import type { PackageInfo } from "./types.ts";
+
+export async function isWorkspace(rootDir: string): Promise<boolean> {
+  const pkg = await Bun.file(join(rootDir, "package.json")).json();
+  return Array.isArray(pkg.workspaces) && pkg.workspaces.length > 0;
+}
+
+export async function getAllPackages(rootDir: string): Promise<PackageInfo[]> {
+  const rootPkg = await Bun.file(join(rootDir, "package.json")).json();
+  const patterns: string[] = rootPkg.workspaces ?? [];
+
+  if (patterns.length === 0) {
+    return [packageInfoFromJson(rootPkg, rootDir)];
+  }
+
+  const packages: PackageInfo[] = [];
+
+  for (const pattern of patterns) {
+    const glob = new Bun.Glob(`${pattern}/package.json`);
+    for await (const match of glob.scan({ cwd: rootDir, absolute: true })) {
+      const dir = match.replace(/\/package\.json$/, "");
+      const pkg = await Bun.file(match).json();
+      packages.push(packageInfoFromJson(pkg, dir));
+    }
+  }
+
+  return packages;
+}
+
+function packageInfoFromJson(pkg: Record<string, unknown>, dir: string): PackageInfo {
+  return {
+    name: (pkg.name as string) ?? "unknown",
+    path: dir,
+    packageJsonPath: join(dir, "package.json"),
+    version: (pkg.version as string) ?? "0.0.0",
+    dependencies: (pkg.dependencies as Record<string, string>) ?? {},
+    devDependencies: (pkg.devDependencies as Record<string, string>) ?? {},
+  };
+}
+
+export async function getChangedPackages(
+  rootDir: string,
+  allPackages: PackageInfo[],
+  sinceRef: string | null,
+): Promise<PackageInfo[]> {
+  if (!sinceRef) return allPackages;
+
+  let result;
+  try {
+    result =
+      await $`git -C ${rootDir} diff --name-only ${sinceRef}..HEAD`.quiet();
+  } catch {
+    return allPackages;
+  }
+
+  const changedFiles = result
+    .text()
+    .trim()
+    .split("\n")
+    .filter(Boolean)
+    .map((f) => join(rootDir, f));
+
+  return allPackages.filter((pkg) =>
+    changedFiles.some((f) => f.startsWith(pkg.path)),
+  );
+}