bunset 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 bunset contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,110 @@
+# bunset
+
+A zero-dependency CLI tool that automates version bumping and changelog generation for Bun workspace monorepos and single packages.
+
+It reads git commit messages since the last tag, categorizes them by type prefix (`[feat]`, `[fix]`, `[test]`), bumps semantic versions, updates `CHANGELOG.md` per package, and optionally commits and tags the result.
+
+## Install
+
+```bash
+bun install
+```
+
+## Usage
+
+```bash
+bun src/index.ts [options]
+```
+
+Or link it globally:
+
+```bash
+bun link
+bunset [options]
+```
+
+### Options
+
+| Flag | Description |
+|------|-------------|
+| `--patch` | Patch version bump (default) |
+| `--minor` | Minor version bump |
+| `--major` | Major version bump |
+| `--all` | Update all workspace packages |
+| `--changed` | Update only changed packages (default for workspaces) |
+| `--no-commit` | Do not commit changes to git (commits by default) |
+| `--tag` | Tag the commit with new version (default) |
+| `--per-package-tags` | Use `pkg@1.2.3` tags instead of prefixed tags |
+| `--tag-prefix` | Tag prefix (default: `v`, e.g. `v1.2.3`) |
+| `--sections` | Comma-separated changelog sections (default: `feat,fix,perf`) |
+| `--dry-run` | Preview changes without writing files, committing, or tagging |
+| `--no-filter-by-package` | Include all commits in every package changelog (monorepo) |
+
+When bump type or scope flags are omitted, interactive prompts will ask.
+
+### Monorepo Per-Package Changelogs
+
+In a monorepo, each package's changelog only includes commits that touched files within that package (enabled by default). A commit that modifies `packages/a/src/index.ts` will only appear in `packages/a/CHANGELOG.md`.
+
+When `--per-package-tags` is set, packages with no matching commits are skipped entirely (no version bump, changelog, or tag). When `--per-package-tags` is not set, all packages are still bumped and get a changelog entry (which may be empty).
+
+Use `--no-filter-by-package` to disable this and include all commits in every package's changelog.
+
+### Commit Message Format
+
+Commits are automatically matched against these patterns (case-insensitive):
+
+```
+[feat] Add user authentication
+[fix]: Resolve crash on startup
+test: Add unit tests for parser
+feat(auth): Add login page
+[fix(ui)]: Fix button alignment
+```
+
+All these styles work:
+- `[type] description` — bracketed
+- `[type]: description` — bracketed with colon
+- `type: description` — conventional commits style
+- `type(scope): description` — with optional scope
+- `[type(scope)] description` — bracketed with optional scope
+
+An optional scope groups commits under a `#### scope` sub-heading within their type section in the changelog.
+
+Recognized type keywords:
+- `feat`, `feature` — listed under **Features**
+- `fix`, `bug`, `bugfix` — listed under **Bug Fixes**
+- `refactor` — listed under **Refactors**
+- `perf` — listed under **Performance**
+- `style` — listed under **Style**
+- `test` — listed under **Tests**
+- `docs` — listed under **Documentation**
+- `build` — listed under **Build**
+- `ops` — listed under **Ops**
+- `chore` — listed under **Chores**
+
+Only sections listed in `--sections` (or the `sections` config option) appear in the changelog. The default is `feat,fix,perf`.
+
+### Config File
+
+Place a `.bunset.toml` in your project root to set persistent defaults so you don't have to pass the same flags every time:
+
+```toml
+bump = "patch"                              # "patch" | "minor" | "major"
+scope = "changed"                           # "all" | "changed"
+commit = true
+tag = true
+per-package-tags = false
+sections = ["feat", "fix", "perf"]          # changelog sections and order
+dry-run = false                             # preview without writing
+filter-by-package = true                    # per-package commit filtering (monorepo)
+tag-prefix = "v"                            # prefix for version tags
+```
+
+All fields are optional. CLI flags always take priority over config values. If `bump` or `scope` is set in config, the interactive prompt for that option is skipped.
+
+## Testing
+
+```bash
+bun test
+```

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "bunset",
+  "version": "0.0.2",
+  "module": "src/index.ts",
+  "type": "module",
+  "bin": {
+    "bunset": "src/index.ts"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "engines": {
+    "bun": "^1.3"
+  },
+  "files": [
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "packageManager": "bun@1.3"
+}

package/src/changelog.test.ts

@@ -0,0 +1,152 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test";
+import { buildChangelogEntry, writeChangelog } from "./changelog.ts";
+import { COMMIT_TYPES } from "./commits.ts";
+import type { GroupedCommits } from "./types.ts";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+function emptyGroups(): GroupedCommits {
+  return {
+    feature: [],
+    bugfix: [],
+    refactor: [],
+    perf: [],
+    style: [],
+    test: [],
+    docs: [],
+    build: [],
+    ops: [],
+    chore: [],
+  };
+}
+
+describe("buildChangelogEntry", () => {
+  test("builds entry with specified sections", () => {
+    const groups: GroupedCommits = {
+      ...emptyGroups(),
+      feature: [
+        { hash: "a", message: "", type: "feature", commitScope: null, files: [], description: "Add login" },
+      ],
+      bugfix: [
+        { hash: "b", message: "", type: "bugfix", commitScope: null, files: [], description: "Fix crash" },
+      ],
+      test: [
+        { hash: "c", message: "", type: "test", commitScope: null, files: [], description: "Add tests" },
+      ],
+    };
+    const entry = buildChangelogEntry("1.2.0", groups, [], COMMIT_TYPES);
+    expect(entry).toContain("## 1.2.0");
+    expect(entry).toContain("### Features");
+    expect(entry).toContain("- Add login");
+    expect(entry).toContain("### Bug Fixes");
+    expect(entry).toContain("- Fix crash");
+    expect(entry).toContain("### Tests");
+    expect(entry).toContain("- Add tests");
+  });
+
+  test("only includes configured sections", () => {
+    const groups: GroupedCommits = {
+      ...emptyGroups(),
+      feature: [
+        { hash: "a", message: "", type: "feature", commitScope: null, files: [], description: "New thing" },
+      ],
+      test: [
+        { hash: "b", message: "", type: "test", commitScope: null, files: [], description: "Add tests" },
+      ],
+    };
+    const entry = buildChangelogEntry("1.0.0", groups);
+    expect(entry).toContain("### Features");
+    expect(entry).not.toContain("### Tests");
+  });
+
+  test("omits empty sections", () => {
+    const groups: GroupedCommits = {
+      ...emptyGroups(),
+      feature: [
+        { hash: "a", message: "", type: "feature", commitScope: null, files: [], description: "New thing" },
+      ],
+    };
+    const entry = buildChangelogEntry("1.0.0", groups);
+    expect(entry).toContain("### Features");
+    expect(entry).not.toContain("### Bug Fixes");
+    expect(entry).not.toContain("### Performance");
+  });
+
+  test("groups scoped commits under sub-headings", () => {
+    const groups: GroupedCommits = {
+      ...emptyGroups(),
+      feature: [
+        { hash: "a", message: "", type: "feature", commitScope: null, files: [], description: "Global feature" },
+        { hash: "b", message: "", type: "feature", commitScope: "auth", files: [], description: "Add login" },
+        { hash: "c", message: "", type: "feature", commitScope: "auth", files: [], description: "Add logout" },
+        { hash: "d", message: "", type: "feature", commitScope: "ui", files: [], description: "New dashboard" },
+      ],
+    };
+    const entry = buildChangelogEntry("1.0.0", groups);
+    expect(entry).toContain("### Features");
+    expect(entry).toContain("- Global feature");
+    expect(entry).toContain("#### auth");
+    expect(entry).toContain("- Add login");
+    expect(entry).toContain("- Add logout");
+    expect(entry).toContain("#### ui");
+    expect(entry).toContain("- New dashboard");
+
+    // Unscoped comes before scoped
+    const globalIdx = entry.indexOf("- Global feature");
+    const authIdx = entry.indexOf("#### auth");
+    expect(globalIdx).toBeLessThan(authIdx);
+  });
+
+  test("renders only scoped commits when no unscoped", () => {
+    const groups: GroupedCommits = {
+      ...emptyGroups(),
+      bugfix: [
+        { hash: "a", message: "", type: "bugfix", commitScope: "parser", files: [], description: "Fix edge case" },
+      ],
+    };
+    const entry = buildChangelogEntry("1.0.0", groups);
+    expect(entry).toContain("### Bug Fixes");
+    expect(entry).toContain("#### parser");
+    expect(entry).toContain("- Fix edge case");
+  });
+
+  test("includes updated dependencies", () => {
+    const groups = emptyGroups();
+    const deps = [{ name: "lodash", newVersion: "4.18.0" }];
+    const entry = buildChangelogEntry("2.0.0", groups, deps);
+    expect(entry).toContain("### Updated Dependencies");
+    expect(entry).toContain("- `lodash`: 4.18.0");
+  });
+});
+
+describe("writeChangelog", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), "changelog-test-"));
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  test("creates new changelog if missing", async () => {
+    await writeChangelog(tmpDir, "## 1.0.0\n\n### Features\n\n- Init\n\n");
+    const content = await Bun.file(join(tmpDir, "CHANGELOG.md")).text();
+    expect(content).toStartWith("# Changelog");
+    expect(content).toContain("## 1.0.0");
+  });
+
+  test("prepends entry to existing changelog", async () => {
+    await Bun.write(
+      join(tmpDir, "CHANGELOG.md"),
+      "# Changelog\n\n## 0.1.0\n\n- Old entry\n",
+    );
+    await writeChangelog(tmpDir, "## 1.0.0\n\n### Features\n\n- New\n\n");
+    const content = await Bun.file(join(tmpDir, "CHANGELOG.md")).text();
+    const idx1 = content.indexOf("## 1.0.0");
+    const idx2 = content.indexOf("## 0.1.0");
+    expect(idx1).toBeLessThan(idx2);
+  });
+});

package/src/changelog.ts

@@ -0,0 +1,96 @@
+import type { CommitType, GroupedCommits, UpdatedDependency } from "./types.ts";
+import { DEFAULT_SECTIONS } from "./commits.ts";
+
+const SECTION_HEADINGS: Record<CommitType, string> = {
+  feature: "Features",
+  bugfix: "Bug Fixes",
+  refactor: "Refactors",
+  perf: "Performance",
+  style: "Style",
+  test: "Tests",
+  docs: "Documentation",
+  build: "Build",
+  ops: "Ops",
+  chore: "Chores",
+};
+
+export function buildChangelogEntry(
+  version: string,
+  groups: GroupedCommits,
+  updatedDeps: UpdatedDependency[] = [],
+  sections: CommitType[] = DEFAULT_SECTIONS,
+): string {
+  const lines: string[] = [`## ${version}`, ""];
+
+  for (const type of sections) {
+    const commits = groups[type];
+    if (commits.length === 0) continue;
+
+    lines.push(`### ${SECTION_HEADINGS[type]}`, "");
+
+    const unscoped = commits.filter((c) => !c.commitScope);
+    const scoped = new Map<string, typeof commits>();
+    for (const c of commits) {
+      if (c.commitScope) {
+        const list = scoped.get(c.commitScope);
+        if (list) list.push(c);
+        else scoped.set(c.commitScope, [c]);
+      }
+    }
+
+    for (const c of unscoped) {
+      lines.push(`- ${c.description}`);
+    }
+    if (unscoped.length > 0 && scoped.size > 0) {
+      lines.push("");
+    }
+
+    for (const [scope, scopeCommits] of scoped) {
+      lines.push(`#### ${scope}`, "");
+      for (const c of scopeCommits) {
+        lines.push(`- ${c.description}`);
+      }
+      lines.push("");
+    }
+
+    if (unscoped.length > 0 && scoped.size === 0) {
+      lines.push("");
+    }
+  }
+
+  if (updatedDeps.length > 0) {
+    lines.push("### Updated Dependencies", "");
+    for (const dep of updatedDeps) {
+      lines.push(`- \`${dep.name}\`: ${dep.newVersion}`);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+export async function writeChangelog(
+  dir: string,
+  entry: string,
+): Promise<void> {
+  const path = `${dir}/CHANGELOG.md`;
+  const file = Bun.file(path);
+  const exists = await file.exists();
+
+  if (!exists) {
+    await Bun.write(path, `# Changelog\n\n${entry}`);
+    return;
+  }
+
+  const content = await file.text();
+  const headerEnd = content.indexOf("\n");
+
+  if (headerEnd === -1) {
+    await Bun.write(path, `${content}\n\n${entry}`);
+    return;
+  }
+
+  const header = content.slice(0, headerEnd);
+  const rest = content.slice(headerEnd + 1);
+  await Bun.write(path, `${header}\n\n${entry}${rest}`);
+}

package/src/cli.ts

@@ -0,0 +1,199 @@
+import { parseArgs } from "node:util";
+import type { BumpType, CliOptions, CommitType, PackageScope } from "./types.ts";
+import { normalizeType, DEFAULT_SECTIONS } from "./commits.ts";
+
+export function printHelp(): void {
+  console.log(`bunset - Version bumping and changelog generation for Bun projects
+
+Usage: bunset [options]
+
+Options:
+  --patch              Bump patch version (x.y.Z)
+  --minor              Bump minor version (x.Y.0)
+  --major              Bump major version (X.0.0)
+  --all                Update all packages (monorepo)
+  --changed            Update only changed packages (monorepo)
+  --no-commit          Do not commit the version bump and changelog
+  --no-tag             Do not create git tags for released versions
+  --per-package-tags   Use package-scoped tags (pkg@version) instead of prefixed
+  --tag-prefix <str>   Tag prefix (default: "v", e.g. v1.2.3)
+  --sections <list>    Comma-separated changelog sections (default: feat,fix,perf)
+  --dry-run            Preview changes without writing files, committing, or tagging
+  --no-filter-by-package
+                       Include all commits in every package changelog (monorepo)
+  --help, -h           Show this help message
+
+When --patch/--minor/--major is omitted, you will be prompted interactively.
+In a monorepo, you will be prompted for --all or --changed if neither is given.
+
+Commit format:
+  Commits are matched against these patterns (case-insensitive):
+    [type] description          e.g. [feat] Add auth
+    [type]: description         e.g. [feat]: Add auth
+    type: description           e.g. feat: Add auth
+    type(scope): description    e.g. feat(auth): Add login
+    [type(scope)] description   e.g. [feat(auth)] Add login
+
+  An optional scope groups commits under a sub-heading in the changelog.
+
+  Recognized type keywords:
+    feat, feature          → Features
+    fix, bug, bugfix       → Bug Fixes
+    refactor               → Refactors
+    perf                   → Performance
+    style                  → Style
+    test                   → Tests
+    docs                   → Documentation
+    build                  → Build
+    ops                    → Ops
+    chore                  → Chores
+  Only sections listed in --sections (or config) are included in the changelog.
+  Default sections: feat, fix, perf.
+
+Config:
+  Place a .bunset.toml in your project root to set persistent defaults.
+  CLI flags always override config values. See README for format.`);
+}
+
+export function resolveOptions(
+  isWs: boolean,
+  config: Partial<CliOptions> = {},
+): CliOptions | Promise<CliOptions> {
+  const { values } = parseArgs({
+    args: Bun.argv.slice(2),
+    options: {
+      all: { type: "boolean", default: false },
+      changed: { type: "boolean", default: false },
+      patch: { type: "boolean", default: false },
+      minor: { type: "boolean", default: false },
+      major: { type: "boolean", default: false },
+      commit: { type: "boolean", default: true },
+      tag: { type: "boolean", default: true },
+      "per-package-tags": { type: "boolean", default: false },
+      sections: { type: "string" },
+      "dry-run": { type: "boolean", default: false },
+      "filter-by-package": { type: "boolean", default: true },
+      "tag-prefix": { type: "string" },
+      help: { type: "boolean", short: "h", default: false },
+    },
+    strict: true,
+  });
+
+  if (values.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  const cliBump = resolveBump(values);
+  const cliScope = resolveScope(values, isWs);
+
+  const bump = cliBump ?? config.bump ?? null;
+  const scope = cliScope ?? config.scope ?? (isWs ? null : "all");
+
+  const commit = values.commit === false ? false : (config.commit ?? true);
+  const tag = values.tag === false ? false : (config.tag ?? true);
+  const perPackageTags = values["per-package-tags"]
+    ? true
+    : (config.perPackageTags ?? false);
+
+  const sections = parseSections(values.sections as string | undefined)
+    ?? config.sections
+    ?? DEFAULT_SECTIONS;
+
+  const dryRun = values["dry-run"] ? true : (config.dryRun ?? false);
+
+  const filterByPackage = values["filter-by-package"] === false
+    ? false
+    : (config.filterByPackage ?? true);
+
+  const tagPrefix = values["tag-prefix"] as string | undefined
+    ?? config.tagPrefix
+    ?? "v";
+
+  if (bump && scope) {
+    return { scope, bump, commit, tag, perPackageTags, sections, dryRun, filterByPackage, tagPrefix };
+  }
+
+  return promptForMissing(
+    { commit, tag, perPackageTags, sections, dryRun, filterByPackage, tagPrefix },
+    bump,
+    scope,
+    isWs,
+  );
+}
+
+function resolveBump(values: Record<string, unknown>): BumpType | null {
+  if (values.major) return "major";
+  if (values.minor) return "minor";
+  if (values.patch) return "patch";
+  return null;
+}
+
+function resolveScope(
+  values: Record<string, unknown>,
+  isWs: boolean,
+): PackageScope | null {
+  if (!isWs) return "all";
+  if (values.all) return "all";
+  if (values.changed) return "changed";
+  return null;
+}
+
+function parseSections(raw: string | undefined): CommitType[] | null {
+  if (!raw) return null;
+  const result: CommitType[] = [];
+  for (const part of raw.split(",")) {
+    const type = normalizeType(part.trim());
+    if (type) result.push(type);
+  }
+  return result.length > 0 ? result : null;
+}
+
+interface MergedDefaults {
+  commit: boolean;
+  tag: boolean;
+  perPackageTags: boolean;
+  sections: CommitType[];
+  dryRun: boolean;
+  filterByPackage: boolean;
+  tagPrefix: string;
+}
+
+async function promptForMissing(
+  merged: MergedDefaults,
+  bump: BumpType | null,
+  scope: PackageScope | null,
+  isWs: boolean,
+): Promise<CliOptions> {
+  if (!scope && isWs) {
+    process.stdout.write(
+      "Update packages: (1) ALL packages  (2) Only CHANGED packages [default: 2]: ",
+    );
+    const answer = await readLine();
+    scope = answer.trim() === "1" ? "all" : "changed";
+  }
+
+  if (!bump) {
+    process.stdout.write(
+      "Version bump: (1) patch  (2) minor  (3) major [default: 1]: ",
+    );
+    const answer = await readLine();
+    const choice = answer.trim();
+    if (choice === "3") bump = "major";
+    else if (choice === "2") bump = "minor";
+    else bump = "patch";
+  }
+
+  return {
+    scope: scope ?? "all",
+    bump,
+    ...merged,
+  };
+}
+
+async function readLine(): Promise<string> {
+  for await (const line of console) {
+    return line;
+  }
+  return "";
+}