bunset 0.0.2

package/src/commits.test.ts

@@ -0,0 +1,265 @@
+import { test, expect, describe } from "bun:test";
+import { parseCommit, groupCommits, filterCommitsForPackage } from "./commits.ts";
+import type { ParsedCommit } from "./types.ts";
+
+describe("parseCommit", () => {
+  // [type] description
+  test("parses [feat] commit", () => {
+    const result = parseCommit("abc123", "[feat] Add user auth");
+    expect(result.type).toBe("feature");
+    expect(result.commitScope).toBeNull();
+    expect(result.files).toEqual([]);
+    expect(result.description).toBe("Add user auth");
+  });
+
+  test("parses [feature] commit", () => {
+    const result = parseCommit("abc123", "[feature] Add login");
+    expect(result.type).toBe("feature");
+    expect(result.description).toBe("Add login");
+  });
+
+  test("parses [fix] commit", () => {
+    const result = parseCommit("def456", "[fix] Resolve crash on startup");
+    expect(result.type).toBe("bugfix");
+    expect(result.description).toBe("Resolve crash on startup");
+  });
+
+  test("parses [bug] commit", () => {
+    const result = parseCommit("def456", "[bug] Fix null pointer");
+    expect(result.type).toBe("bugfix");
+  });
+
+  test("parses [bugfix] commit", () => {
+    const result = parseCommit("def456", "[bugfix] Handle edge case");
+    expect(result.type).toBe("bugfix");
+  });
+
+  test("parses [test] commit", () => {
+    const result = parseCommit("ghi789", "[test] Add unit tests for parser");
+    expect(result.type).toBe("test");
+    expect(result.description).toBe("Add unit tests for parser");
+  });
+
+  test("parses [refactor] commit", () => {
+    const result = parseCommit("a1", "[refactor] Simplify auth module");
+    expect(result.type).toBe("refactor");
+    expect(result.description).toBe("Simplify auth module");
+  });
+
+  test("parses [perf] commit", () => {
+    const result = parseCommit("a2", "[perf] Speed up query");
+    expect(result.type).toBe("perf");
+    expect(result.description).toBe("Speed up query");
+  });
+
+  test("parses [style] commit", () => {
+    const result = parseCommit("a3", "[style] Fix formatting");
+    expect(result.type).toBe("style");
+    expect(result.description).toBe("Fix formatting");
+  });
+
+  test("parses [docs] commit", () => {
+    const result = parseCommit("a4", "[docs] Update readme");
+    expect(result.type).toBe("docs");
+    expect(result.description).toBe("Update readme");
+  });
+
+  test("parses [build] commit", () => {
+    const result = parseCommit("a5", "[build] Update dependencies");
+    expect(result.type).toBe("build");
+    expect(result.description).toBe("Update dependencies");
+  });
+
+  test("parses [ops] commit", () => {
+    const result = parseCommit("a6", "[ops] Update CI pipeline");
+    expect(result.type).toBe("ops");
+    expect(result.description).toBe("Update CI pipeline");
+  });
+
+  test("parses [chore] commit", () => {
+    const result = parseCommit("a7", "[chore] Initial commit");
+    expect(result.type).toBe("chore");
+    expect(result.description).toBe("Initial commit");
+  });
+
+  // [type]: description
+  test("parses [feat]: commit", () => {
+    const result = parseCommit("abc123", "[feat]: Add user auth");
+    expect(result.type).toBe("feature");
+    expect(result.description).toBe("Add user auth");
+  });
+
+  test("parses [fix]: commit", () => {
+    const result = parseCommit("def456", "[fix]: Resolve crash");
+    expect(result.type).toBe("bugfix");
+    expect(result.description).toBe("Resolve crash");
+  });
+
+  // type: description
+  test("parses feat: commit", () => {
+    const result = parseCommit("abc123", "feat: Add user auth");
+    expect(result.type).toBe("feature");
+    expect(result.description).toBe("Add user auth");
+  });
+
+  test("parses fix: commit", () => {
+    const result = parseCommit("def456", "fix: Resolve crash");
+    expect(result.type).toBe("bugfix");
+    expect(result.description).toBe("Resolve crash");
+  });
+
+  test("parses test: commit", () => {
+    const result = parseCommit("ghi789", "test: Add parser tests");
+    expect(result.type).toBe("test");
+    expect(result.description).toBe("Add parser tests");
+  });
+
+  test("parses refactor: commit", () => {
+    const result = parseCommit("b1", "refactor: Simplify logic");
+    expect(result.type).toBe("refactor");
+    expect(result.description).toBe("Simplify logic");
+  });
+
+  test("parses perf: commit", () => {
+    const result = parseCommit("b2", "perf: Optimize render");
+    expect(result.type).toBe("perf");
+    expect(result.description).toBe("Optimize render");
+  });
+
+  test("parses chore: commit", () => {
+    const result = parseCommit("b3", "chore: Bump version");
+    expect(result.type).toBe("chore");
+    expect(result.description).toBe("Bump version");
+  });
+
+  // Scoped commits: [type(scope)] description
+  test("parses [feat(auth)] commit with scope", () => {
+    const result = parseCommit("s1", "[feat(auth)] Add login");
+    expect(result.type).toBe("feature");
+    expect(result.commitScope).toBe("auth");
+    expect(result.description).toBe("Add login");
+  });
+
+  test("parses [fix(ui)] commit with scope", () => {
+    const result = parseCommit("s2", "[fix(ui)] Fix button color");
+    expect(result.type).toBe("bugfix");
+    expect(result.commitScope).toBe("ui");
+    expect(result.description).toBe("Fix button color");
+  });
+
+  // Scoped commits: [type(scope)]: description
+  test("parses [feat(api)]: commit with scope and colon", () => {
+    const result = parseCommit("s3", "[feat(api)]: Add endpoint");
+    expect(result.type).toBe("feature");
+    expect(result.commitScope).toBe("api");
+    expect(result.description).toBe("Add endpoint");
+  });
+
+  // Scoped commits: type(scope): description
+  test("parses feat(auth): commit with scope", () => {
+    const result = parseCommit("s4", "feat(auth): Add logout");
+    expect(result.type).toBe("feature");
+    expect(result.commitScope).toBe("auth");
+    expect(result.description).toBe("Add logout");
+  });
+
+  test("parses fix(parser): commit with scope", () => {
+    const result = parseCommit("s5", "fix(parser): Handle edge case");
+    expect(result.type).toBe("bugfix");
+    expect(result.commitScope).toBe("parser");
+    expect(result.description).toBe("Handle edge case");
+  });
+
+  // Edge cases
+  test("returns null type for unrecognized [prefix]", () => {
+    const result = parseCommit("jkl012", "[unknown] Something");
+    expect(result.type).toBeNull();
+    expect(result.description).toBe("Something");
+  });
+
+  test("returns null type for unrecognized prefix:", () => {
+    const result = parseCommit("jkl012", "unknown: Something");
+    expect(result.type).toBeNull();
+    expect(result.description).toBe("Something");
+  });
+
+  test("returns null type for plain commits", () => {
+    const result = parseCommit("mno345", "Regular commit message");
+    expect(result.type).toBeNull();
+    expect(result.commitScope).toBeNull();
+    expect(result.description).toBe("Regular commit message");
+  });
+
+  test("is case-insensitive for type keyword", () => {
+    const result = parseCommit("stu901", "[FEAT] Uppercase type");
+    expect(result.type).toBe("feature");
+  });
+
+  test("is case-insensitive for bare prefix", () => {
+    const result = parseCommit("stu901", "FEAT: Uppercase type");
+    expect(result.type).toBe("feature");
+  });
+
+  test("handles missing close bracket", () => {
+    const result = parseCommit("vwx234", "[feat No closing bracket");
+    expect(result.type).toBeNull();
+  });
+});
+
+describe("groupCommits", () => {
+  test("groups commits by type", () => {
+    const commits: ParsedCommit[] = [
+      { hash: "a", message: "", type: "feature", commitScope: null, description: "F1", files: [] },
+      { hash: "b", message: "", type: "bugfix", commitScope: null, description: "B1", files: [] },
+      { hash: "c", message: "", type: "test", commitScope: null, description: "T1", files: [] },
+      { hash: "d", message: "", type: "feature", commitScope: "auth", description: "F2", files: [] },
+      { hash: "e", message: "", type: "refactor", commitScope: null, description: "R1", files: [] },
+      { hash: "f", message: "", type: "chore", commitScope: null, description: "C1", files: [] },
+      { hash: "g", message: "", type: null, commitScope: null, description: "Ignored", files: [] },
+    ];
+    const groups = groupCommits(commits);
+    expect(groups.feature).toHaveLength(2);
+    expect(groups.bugfix).toHaveLength(1);
+    expect(groups.test).toHaveLength(1);
+    expect(groups.refactor).toHaveLength(1);
+    expect(groups.chore).toHaveLength(1);
+    expect(groups.perf).toHaveLength(0);
+    expect(groups.docs).toHaveLength(0);
+  });
+
+  test("handles empty commit list", () => {
+    const groups = groupCommits([]);
+    expect(groups.feature).toHaveLength(0);
+    expect(groups.bugfix).toHaveLength(0);
+    expect(groups.test).toHaveLength(0);
+  });
+});
+
+describe("filterCommitsForPackage", () => {
+  const commits: ParsedCommit[] = [
+    { hash: "a", message: "", type: "feature", commitScope: null, description: "A feat", files: ["packages/a/src/index.ts"] },
+    { hash: "b", message: "", type: "bugfix", commitScope: null, description: "B fix", files: ["packages/b/src/main.ts"] },
+    { hash: "c", message: "", type: "feature", commitScope: null, description: "Both", files: ["packages/a/lib/x.ts", "packages/b/lib/y.ts"] },
+    { hash: "d", message: "", type: "feature", commitScope: null, description: "No files", files: [] },
+  ];
+
+  test("filters commits to only those touching the package", () => {
+    const filtered = filterCommitsForPackage(commits, "/root/packages/a", "/root");
+    expect(filtered).toHaveLength(3); // a, c (touches a), d (no files = included)
+    expect(filtered.map((c) => c.hash)).toEqual(["a", "c", "d"]);
+  });
+
+  test("filters for a different package", () => {
+    const filtered = filterCommitsForPackage(commits, "/root/packages/b", "/root");
+    expect(filtered).toHaveLength(3); // b, c (touches b), d (no files = included)
+    expect(filtered.map((c) => c.hash)).toEqual(["b", "c", "d"]);
+  });
+
+  test("includes commits with no files (fallback)", () => {
+    const noFileCommits: ParsedCommit[] = [
+      { hash: "x", message: "", type: "feature", commitScope: null, description: "X", files: [] },
+    ];
+    const filtered = filterCommitsForPackage(noFileCommits, "/root/packages/a", "/root");
+    expect(filtered).toHaveLength(1);
+  });
+});

package/src/commits.ts

@@ -0,0 +1,87 @@
+import type { CommitType, ParsedCommit, GroupedCommits } from "./types.ts";
+
+export const DEFAULT_SECTIONS: CommitType[] = ["feature", "bugfix", "perf"];
+
+const TYPE_MAP: Record<string, CommitType> = {
+  feat: "feature",
+  feature: "feature",
+  fix: "bugfix",
+  bug: "bugfix",
+  bugfix: "bugfix",
+  refactor: "refactor",
+  perf: "perf",
+  style: "style",
+  test: "test",
+  docs: "docs",
+  build: "build",
+  ops: "ops",
+  chore: "chore",
+};
+
+export const COMMIT_TYPES: CommitType[] = [
+  "feature",
+  "bugfix",
+  "refactor",
+  "perf",
+  "style",
+  "test",
+  "docs",
+  "build",
+  "ops",
+  "chore",
+];
+
+export function normalizeType(keyword: string): CommitType | null {
+  return TYPE_MAP[keyword.toLowerCase()] ?? null;
+}
+
+// Matches: [type(scope)] desc, [type]: desc, type(scope): desc, type: desc
+const COMMIT_PATTERN = /^\[([^\]]+)\]:?\s*(.*)$|^(\w+(?:\([^)]*\))?):\s+(.*)$/;
+const SCOPE_PATTERN = /^(\w+)\(([^)]*)\)$/;
+
+export function parseCommit(hash: string, message: string): ParsedCommit {
+  const trimmed = message.trim();
+  const match = COMMIT_PATTERN.exec(trimmed);
+
+  if (!match) {
+    return { hash, message: trimmed, type: null, commitScope: null, description: trimmed, files: [] };
+  }
+
+  const raw = (match[1] ?? match[3])!.trim();
+  const description = (match[2] ?? match[4])!.trim();
+
+  const scopeMatch = SCOPE_PATTERN.exec(raw);
+  const keyword = scopeMatch ? scopeMatch[1]! : raw;
+  const commitScope = scopeMatch ? scopeMatch[2]!.trim() : null;
+
+  const type = TYPE_MAP[keyword.toLowerCase()] ?? null;
+
+  return { hash, message: trimmed, type, commitScope, description, files: [] };
+}
+
+export function filterCommitsForPackage(
+  commits: ParsedCommit[],
+  packagePath: string,
+  rootDir: string,
+): ParsedCommit[] {
+  const relPkgPath = packagePath.startsWith(rootDir)
+    ? packagePath.slice(rootDir.length + 1)
+    : packagePath;
+  return commits.filter(
+    (c) => c.files.length === 0 || c.files.some((f) => f.startsWith(relPkgPath + "/")),
+  );
+}
+
+export function groupCommits(commits: ParsedCommit[]): GroupedCommits {
+  const groups = Object.fromEntries(
+    COMMIT_TYPES.map((t) => [t, [] as ParsedCommit[]]),
+  ) as GroupedCommits;
+
+  for (const commit of commits) {
+    if (commit.type) {
+      groups[commit.type].push(commit);
+    }
+  }
+
+  return groups;
+}

package/src/config.ts

@@ -0,0 +1,64 @@
+import path from "node:path";
+import type { CliOptions, CommitType } from "./types.ts";
+import { normalizeType } from "./commits.ts";
+
+const CONFIG_FILE = ".bunset.toml";
+
+const VALID_BUMPS = new Set(["patch", "minor", "major"]);
+const VALID_SCOPES = new Set(["all", "changed"]);
+
+export async function loadConfig(
+  cwd: string,
+): Promise<Partial<CliOptions>> {
+  const file = Bun.file(path.join(cwd, CONFIG_FILE));
+
+  if (!(await file.exists())) return {};
+
+  const raw = Bun.TOML.parse(await file.text()) as Record<string, unknown>;
+  const config: Partial<CliOptions> = {};
+
+  if (typeof raw.bump === "string" && VALID_BUMPS.has(raw.bump)) {
+    config.bump = raw.bump as CliOptions["bump"];
+  }
+
+  if (typeof raw.scope === "string" && VALID_SCOPES.has(raw.scope)) {
+    config.scope = raw.scope as CliOptions["scope"];
+  }
+
+  if (typeof raw.commit === "boolean") {
+    config.commit = raw.commit;
+  }
+
+  if (typeof raw.tag === "boolean") {
+    config.tag = raw.tag;
+  }
+
+  if (typeof raw["per-package-tags"] === "boolean") {
+    config.perPackageTags = raw["per-package-tags"];
+  }
+
+  if (typeof raw["dry-run"] === "boolean") {
+    config.dryRun = raw["dry-run"];
+  }
+
+  if (typeof raw["filter-by-package"] === "boolean") {
+    config.filterByPackage = raw["filter-by-package"];
+  }
+
+  if (typeof raw["tag-prefix"] === "string") {
+    config.tagPrefix = raw["tag-prefix"];
+  }
+
+  if (Array.isArray(raw.sections)) {
+    const sections: CommitType[] = [];
+    for (const s of raw.sections) {
+      if (typeof s === "string") {
+        const type = normalizeType(s);
+        if (type) sections.push(type);
+      }
+    }
+    if (sections.length > 0) config.sections = sections;
+  }
+
+  return config;
+}

package/src/deps.ts

@@ -0,0 +1,47 @@
+import { $ } from "bun";
+import type { UpdatedDependency } from "./types.ts";
+
+export async function getUpdatedDependencies(
+  cwd: string,
+  packageJsonPath: string,
+  sinceRef: string | null,
+): Promise<UpdatedDependency[]> {
+  if (!sinceRef) return [];
+
+  let oldPkg: Record<string, unknown>;
+  try {
+    const relativePath = packageJsonPath.startsWith(cwd)
+      ? packageJsonPath.slice(cwd.length + 1)
+      : packageJsonPath;
+    const result =
+      await $`git -C ${cwd} show ${sinceRef}:${relativePath}`.quiet();
+    oldPkg = JSON.parse(result.text());
+  } catch {
+    return [];
+  }
+
+  const currentPkg = await Bun.file(packageJsonPath).json();
+  const updated: UpdatedDependency[] = [];
+
+  const oldDeps = (oldPkg.dependencies ?? {}) as Record<string, string>;
+  const oldDevDeps = (oldPkg.devDependencies ?? {}) as Record<string, string>;
+  const newDeps = (currentPkg.dependencies ?? {}) as Record<string, string>;
+  const newDevDeps = (currentPkg.devDependencies ?? {}) as Record<
+    string,
+    string
+  >;
+
+  for (const [name, version] of Object.entries(newDeps)) {
+    if (oldDeps[name] && oldDeps[name] !== version) {
+      updated.push({ name, newVersion: version });
+    }
+  }
+
+  for (const [name, version] of Object.entries(newDevDeps)) {
+    if (oldDevDeps[name] && oldDevDeps[name] !== version) {
+      updated.push({ name, newVersion: version });
+    }
+  }
+
+  return updated;
+}

package/src/git.ts

@@ -0,0 +1,65 @@
+import { $ } from "bun";
+
+export async function getLastTag(cwd: string): Promise<string | null> {
+  try {
+    const result = await $`git -C ${cwd} describe --tags --abbrev=0`.quiet();
+    return result.text().trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+export async function getCommitsSince(
+  cwd: string,
+  sinceRef: string | null,
+): Promise<{ hash: string; message: string }[]> {
+  let result;
+  if (sinceRef) {
+    result =
+      await $`git -C ${cwd} log ${sinceRef}..HEAD --pretty=format:%H%n%s --no-merges`.quiet();
+  } else {
+    result =
+      await $`git -C ${cwd} log --pretty=format:%H%n%s --no-merges`.quiet();
+  }
+
+  const text = result.text().trim();
+  if (!text) return [];
+
+  const lines = text.split("\n");
+  const commits: { hash: string; message: string }[] = [];
+
+  for (let i = 0; i < lines.length - 1; i += 2) {
+    commits.push({ hash: lines[i]!, message: lines[i + 1]! });
+  }
+
+  return commits;
+}
+
+export async function getCommitFiles(
+  cwd: string,
+  hash: string,
+): Promise<string[]> {
+  try {
+    const result =
+      await $`git -C ${cwd} diff-tree --no-commit-id --name-only -r ${hash}`.quiet();
+    return result
+      .text()
+      .trim()
+      .split("\n")
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+export async function commitAndTag(
+  cwd: string,
+  message: string,
+  tags: string[] = [],
+): Promise<void> {
+  await $`git -C ${cwd} add -A`.quiet();
+  await $`git -C ${cwd} commit -m ${message}`.quiet();
+  for (const tag of tags) {
+    await $`git -C ${cwd} tag ${tag}`.quiet();
+  }
+}