@kcconfigs/commitlint 0.0.1 → 0.1.0-beta.0

package/src/apis/projects.test.ts

@@ -0,0 +1,344 @@
+import { cwd } from "node:process";
+import { vol } from "@kcconfigs/vitest/mocks";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { findBunPackages, findNpmPackages, findPnpmPackages } from "./projects";
+
+describe("Project APIs", () => {
+	afterEach(() => {
+		vol.reset();
+	});
+
+	describe(findNpmPackages.name, () => {
+		beforeEach(() => {
+			vi.mocked(cwd).mockReturnValue("/mock/npm-workspace");
+		});
+
+		test("should find empty packages when no workspaces defined", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "npm-workspace",
+					}),
+				},
+				cwd(),
+			);
+
+			const packages = await findNpmPackages(false);
+
+			expect(cwd()).toEqual("/mock/npm-workspace");
+			expect(packages).toEqual([]);
+		});
+
+		test("should return workspace packages without root", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "npm-workspace",
+						workspaces: ["packages/*"],
+					}),
+					"./packages/pkg-a/package.json": JSON.stringify({
+						name: "@scope/pkg-a",
+					}),
+					"./packages/pkg-b/package.json": JSON.stringify({
+						name: "@scope/pkg-b",
+					}),
+				},
+				cwd(),
+			);
+
+			const packages = await findNpmPackages(false);
+
+			expect(cwd()).toEqual("/mock/npm-workspace");
+			expect(packages.sort()).toEqual(["scope/pkg-a", "scope/pkg-b"].sort());
+		});
+
+		test("should return workspace packages with root", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "npm-workspace",
+						workspaces: ["**"],
+					}),
+					"./packages/pkg-a/package.json": JSON.stringify({
+						name: "@scope/pkg-a",
+					}),
+					"./packages/pkg-b/package.json": JSON.stringify({
+						name: "@scope/pkg-b",
+					}),
+				},
+				cwd(),
+			);
+
+			const packages = await findNpmPackages(true);
+
+			expect(cwd()).toEqual("/mock/npm-workspace");
+			expect(packages.sort()).toEqual(
+				["npm-workspace", "scope/pkg-a", "scope/pkg-b"].sort(),
+			);
+		});
+
+		test("should fallback to directory name when manifest name missing", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "npm-workspace",
+						workspaces: ["packages/*"],
+					}),
+					"./packages/pkg-a/package.json": JSON.stringify({
+						version: "1.0.0",
+					}),
+					"./packages/pkg-b/package.json": JSON.stringify({
+						version: "1.0.0",
+					}),
+				},
+				cwd(),
+			);
+
+			const packages = await findNpmPackages(false);
+
+			expect(cwd()).toEqual("/mock/npm-workspace");
+			expect(packages.sort()).toEqual(["pkg-a", "pkg-b"].sort());
+		});
+
+		test("should handle packages without scope prefix", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "npm-workspace",
+						workspaces: ["packages/*"],
+					}),
+					"./packages/pkg-a/package.json": JSON.stringify({
+						name: "pkg-a",
+					}),
+					"./packages/pkg-b/package.json": JSON.stringify({
+						name: "pkg-b",
+					}),
+				},
+				cwd(),
+			);
+
+			const packages = await findNpmPackages(false);
+
+			expect(cwd()).toEqual("/mock/npm-workspace");
+			expect(packages.sort()).toEqual(["pkg-a", "pkg-b"].sort());
+		});
+	});
+
+	describe(findPnpmPackages.name, () => {
+		beforeEach(() => {
+			vi.mocked(cwd).mockReturnValue("/mock/pnpm-workspace");
+		});
+
+		test("should find empty packages when no packages defined", async () => {
+			vol.fromJSON(
+				{
+					"./pnpm-workspace.yaml": "",
+				},
+				cwd(),
+			);
+
+			const packages = await findPnpmPackages(false);
+
+			expect(cwd()).toEqual("/mock/pnpm-workspace");
+			expect(packages).toEqual([]);
+		});
+
+		test("should return workspace packages without root", async () => {
+			vol.fromJSON(
+				{
+					"./pnpm-workspace.yaml": "packages:\n  - 'packages/*'",
+					"./packages/pkg-a/package.json": JSON.stringify({
+						name: "@scope/pkg-a",
+					}),
+					"./packages/pkg-b/package.json": JSON.stringify({
+						name: "@scope/pkg-b",
+					}),
+				},
+				cwd(),
+			);
+
+			const packages = await findPnpmPackages(false);
+
+			expect(cwd()).toEqual("/mock/pnpm-workspace");
+			expect(packages.sort()).toEqual(["scope/pkg-a", "scope/pkg-b"].sort());
+		});
+
+		test("should return workspace packages with root", async () => {
+			vol.fromJSON(
+				{
+					"./pnpm-workspace.yaml": "packages:\n  - '**'",
+					"./package.json": JSON.stringify({
+						name: "pnpm-workspace",
+					}),
+					"./packages/pkg-a/package.json": JSON.stringify({
+						name: "@scope/pkg-a",
+					}),
+					"./packages/pkg-b/package.json": JSON.stringify({
+						name: "@scope/pkg-b",
+					}),
+				},
+				cwd(),
+			);
+
+			const packages = await findPnpmPackages(true);
+
+			expect(cwd()).toEqual("/mock/pnpm-workspace");
+			expect(packages.sort()).toEqual(
+				["pnpm-workspace", "scope/pkg-a", "scope/pkg-b"].sort(),
+			);
+		});
+
+		test("should fallback to directory name when manifest name missing", async () => {
+			vol.fromJSON(
+				{
+					"./pnpm-workspace.yaml": "packages:\n  - 'packages/*'",
+					"./packages/pkg-a/package.json": JSON.stringify({
+						version: "1.0.0",
+					}),
+					"./packages/pkg-b/package.json": JSON.stringify({
+						version: "1.0.0",
+					}),
+				},
+				cwd(),
+			);
+
+			const packages = await findPnpmPackages(false);
+
+			expect(cwd()).toEqual("/mock/pnpm-workspace");
+			expect(packages.sort()).toEqual(["pkg-a", "pkg-b"].sort());
+		});
+
+		test("should handle multiple package patterns", async () => {
+			vol.fromJSON(
+				{
+					"./pnpm-workspace.yaml": "packages:\n  - 'packages/*'\n  - 'apps/*'",
+					"./packages/pkg-a/package.json": JSON.stringify({
+						name: "@scope/pkg-a",
+					}),
+					"./apps/app-a/package.json": JSON.stringify({
+						name: "@scope/app-a",
+					}),
+				},
+				cwd(),
+			);
+
+			const packages = await findPnpmPackages(false);
+
+			expect(cwd()).toEqual("/mock/pnpm-workspace");
+			expect(packages.sort()).toEqual(["scope/pkg-a", "scope/app-a"].sort());
+		});
+
+		test("should default to false when includeRoot is undefined", async () => {
+			vol.fromJSON(
+				{
+					"./pnpm-workspace.yaml": "packages:\n  - '**'",
+					"./package.json": JSON.stringify({
+						name: "pnpm-workspace",
+					}),
+					"./packages/pkg-a/package.json": JSON.stringify({
+						name: "@scope/pkg-a",
+					}),
+				},
+				cwd(),
+			);
+
+			const packages = await findPnpmPackages();
+
+			expect(cwd()).toEqual("/mock/pnpm-workspace");
+			expect(packages.sort()).toEqual(["scope/pkg-a"].sort());
+		});
+	});
+
+	describe(findBunPackages.name, () => {
+		beforeEach(() => {
+			vi.mocked(cwd).mockReturnValue("/mock/bun-workspace");
+		});
+
+		test("should find empty packages when no workspaces defined", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "bun-workspace",
+					}),
+				},
+				cwd(),
+			);
+
+			const packages = await findBunPackages(false);
+
+			expect(cwd()).toEqual("/mock/bun-workspace");
+			expect(packages).toEqual([]);
+		});
+
+		test("should return workspace packages without root", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "bun-workspace",
+						workspaces: ["packages/*"],
+					}),
+					"./packages/pkg-a/package.json": JSON.stringify({
+						name: "@scope/pkg-a",
+					}),
+					"./packages/pkg-b/package.json": JSON.stringify({
+						name: "@scope/pkg-b",
+					}),
+				},
+				cwd(),
+			);
+
+			const packages = await findBunPackages(false);
+
+			expect(cwd()).toEqual("/mock/bun-workspace");
+			expect(packages.sort()).toEqual(["scope/pkg-a", "scope/pkg-b"].sort());
+		});
+
+		test("should return workspace packages with root", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "bun-workspace",
+						workspaces: ["**"],
+					}),
+					"./packages/pkg-a/package.json": JSON.stringify({
+						name: "@scope/pkg-a",
+					}),
+					"./packages/pkg-b/package.json": JSON.stringify({
+						name: "@scope/pkg-b",
+					}),
+				},
+				cwd(),
+			);
+
+			const packages = await findBunPackages(true);
+
+			expect(cwd()).toEqual("/mock/bun-workspace");
+			expect(packages.sort()).toEqual(
+				["bun-workspace", "scope/pkg-a", "scope/pkg-b"].sort(),
+			);
+		});
+
+		test("should fallback to directory name when manifest name missing", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "bun-workspace",
+						workspaces: ["packages/*"],
+					}),
+					"./packages/pkg-a/package.json": JSON.stringify({
+						version: "1.0.0",
+					}),
+					"./packages/pkg-b/package.json": JSON.stringify({
+						version: "1.0.0",
+					}),
+				},
+				cwd(),
+			);
+
+			const packages = await findBunPackages(false);
+
+			expect(cwd()).toEqual("/mock/bun-workspace");
+			expect(packages.sort()).toEqual(["pkg-a", "pkg-b"].sort());
+		});
+	});
+});

package/src/apis/projects.ts

@@ -0,0 +1,52 @@
+import { readFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { cwd as wd } from "node:process";
+import { findWorkspacePackagesNoCheck } from "@pnpm/workspace.find-packages";
+import { parse } from "yaml";
+
+const findPackages = async (
+	cwd: string,
+	patterns: WithUndefined<string[]>,
+	includeRoot: WithUndefined<boolean>,
+) => {
+	const packages = await findWorkspacePackagesNoCheck(cwd, {
+		patterns: patterns ?? ["**"],
+	});
+
+	return packages
+		.filter((pkg) => (includeRoot ?? false) || pkg.rootDir !== cwd)
+		.map((pkg) => pkg.manifest.name ?? basename(pkg.rootDirRealPath))
+		.map((name) => (name.startsWith("@") ? name.slice(1) : name));
+};
+
+export const findPnpmPackages = async (
+	includeRoot?: boolean,
+): Promise<string[]> => {
+	const cwd = wd();
+
+	const pnpmWorkspace = await readFile(join(cwd, "pnpm-workspace.yaml"), {
+		encoding: "utf8",
+	});
+
+	const workspace = parse(pnpmWorkspace);
+	return findPackages(cwd, workspace?.packages, includeRoot);
+};
+
+export const findNpmPackages = async (
+	includeRoot?: boolean,
+): Promise<string[]> => {
+	const cwd = wd();
+
+	const { workspaces } = JSON.parse(
+		await readFile(join(cwd, "package.json"), {
+			encoding: "utf8",
+		}),
+	);
+	return findPackages(cwd, workspaces, includeRoot);
+};
+
+export const findBunPackages = async (
+	includeRoot?: boolean,
+): Promise<string[]> => {
+	return findNpmPackages(includeRoot);
+};

package/src/apis/scopes.test.ts

@@ -0,0 +1,126 @@
+import { cwd } from "node:process";
+import { vol } from "@kcconfigs/vitest/mocks";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { getScopes } from "./scopes";
+
+describe("Scopes APIs", () => {
+	afterEach(() => {
+		vol.reset();
+	});
+
+	describe(getScopes.name, () => {
+		beforeEach(() => {
+			vi.mocked(cwd).mockReturnValue("/mock/workspace");
+		});
+
+		test("should return default scopes when auto is false and no scopes provided", async () => {
+			const scopes = await getScopes(false);
+
+			expect(scopes.sort()).toEqual(
+				["core", "config", "script", "deps", "deps-dev"].sort(),
+			);
+		});
+
+		test("should return user-provided scopes when auto is false", async () => {
+			const scopes = await getScopes(false, ["custom1", "custom2"]);
+
+			expect(scopes.sort()).toEqual(["custom1", "custom2"].sort());
+		});
+
+		test("should detect pnpm workspace and return package scopes", async () => {
+			vol.fromJSON(
+				{
+					"./pnpm-workspace.yaml": "packages:\n  - 'packages/*'",
+					"./packages/pkg-a/package.json": JSON.stringify({
+						name: "@scope/pkg-a",
+					}),
+				},
+				cwd(),
+			);
+
+			const scopes = await getScopes(true);
+
+			expect(scopes.sort()).toEqual(["scope/pkg-a"].sort());
+		});
+
+		test("should detect bun workspace with bun.lock", async () => {
+			vol.fromJSON(
+				{
+					"./bun.lock": "",
+					"./package.json": JSON.stringify({
+						name: "bun-workspace",
+						workspaces: ["packages/*"],
+					}),
+					"./packages/pkg-a/package.json": JSON.stringify({
+						name: "@scope/pkg-a",
+					}),
+				},
+				cwd(),
+			);
+
+			const scopes = await getScopes(true);
+
+			expect(scopes.sort()).toEqual(["scope/pkg-a"].sort());
+		});
+
+		test("should detect bun workspace with bun.lockb", async () => {
+			vol.fromJSON(
+				{
+					"./bun.lockb": "",
+					"./package.json": JSON.stringify({
+						name: "bun-workspace",
+						workspaces: ["packages/*"],
+					}),
+					"./packages/pkg-a/package.json": JSON.stringify({
+						name: "@scope/pkg-a",
+					}),
+				},
+				cwd(),
+			);
+
+			const scopes = await getScopes(true);
+
+			expect(scopes.sort()).toEqual(["scope/pkg-a"].sort());
+		});
+
+		test("should fallback to npm when no specific workspace file found", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "npm-workspace",
+						workspaces: ["packages/*"],
+					}),
+					"./packages/pkg-a/package.json": JSON.stringify({
+						name: "@scope/pkg-a",
+					}),
+				},
+				cwd(),
+			);
+
+			const scopes = await getScopes(true);
+
+			expect(scopes.sort()).toEqual(["scope/pkg-a"].sort());
+		});
+
+		test("should merge user scopes with auto-detected scopes", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "npm-workspace",
+						workspaces: ["packages/*"],
+					}),
+					"./packages/pkg-a/package.json": JSON.stringify({
+						name: "@scope/pkg-a",
+					}),
+				},
+				cwd(),
+			);
+
+			const scopes = await getScopes(true, ["custom1", "custom2"]);
+
+			expect(scopes.sort()).toEqual(
+				["custom1", "custom2", "scope/pkg-a"].sort(),
+			);
+		});
+	});
+});

package/src/apis/scopes.ts

@@ -0,0 +1,56 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { cwd as wd } from "node:process";
+import { findBunPackages, findNpmPackages, findPnpmPackages } from "./projects";
+
+/**
+ * Automatically detects and retrieves project scopes based on the package manager in use.
+ *
+ * Determines the package manager by checking for workspace configuration files:
+ * - pnpm: Checks for pnpm-workspace.yaml
+ * - bun: Checks for bun.lock or bun.lockb
+ * - npm: Falls back to npm package detection
+ *
+ * @param includeRoot - Whether to include the root package in the results
+ * @returns Array of detected project scope names
+ */
+const getAutoScope = (includeRoot: boolean) => {
+	const cwd = wd();
+
+	if (existsSync(join(cwd, "pnpm-workspace.yaml"))) {
+		return findPnpmPackages(includeRoot);
+	} else if (
+		existsSync(join(cwd, "bun.lock")) ||
+		existsSync(join(cwd, "bun.lockb"))
+	) {
+		return findBunPackages(includeRoot);
+	}
+
+	return findNpmPackages(includeRoot);
+};
+
+/**
+ * Retrieves a merged list of commit scopes based on automatic detection and user input.
+ *
+ * Combines user-provided scopes with automatically detected project scopes.
+ * If no scopes are provided, returns a default set of common scope categories.
+ *
+ * @param auto - Whether to automatically detect scopes from workspace packages
+ * @param scopes - Optional user-provided scopes to include
+ * @returns Merged array of all available scopes
+ *
+ */
+export const getScopes = async (
+	auto: boolean,
+	scopes?: string[],
+): Promise<string[]> => {
+	const _scopes: string[] = [];
+
+	if (scopes) _scopes.push(...scopes);
+	if (auto) _scopes.push(...(await getAutoScope(false)));
+
+	if (_scopes.length === 0) {
+		_scopes.push("core", "config", "script", "deps", "deps-dev");
+	}
+	return _scopes;
+};

package/src/apis/types.test.ts

@@ -0,0 +1,88 @@
+/** biome-ignore-all lint/complexity/useLiteralKeys: Conflict with ts(4111) */
+
+import { describe, expect, test } from "vitest";
+import { getTypes } from "./types";
+
+describe("Types APIs", () => {
+	describe(getTypes.name, () => {
+		test("should return standard types when mode is 'standard'", () => {
+			const types = getTypes("standard");
+
+			expect(Object.keys(types).sort()).toEqual(
+				[
+					"feat",
+					"perf",
+					"fix",
+					"docs",
+					"test",
+					"style",
+					"build",
+					"refactor",
+					"ci",
+					"chore",
+					"revert",
+				].sort(),
+			);
+			expect(types["feat"]).toEqual({
+				description: "A new feature",
+				title: "Features",
+				emoji: "✨",
+			});
+		});
+
+		test("should return minimal types when mode is 'minimal'", () => {
+			const types = getTypes("minimal");
+
+			expect(Object.keys(types).sort()).toEqual(
+				["feat", "perf", "fix", "chore"].sort(),
+			);
+			expect(types["feat"]).toEqual({
+				description: "A new feature",
+				title: "Features",
+				emoji: "✨",
+			});
+		});
+
+		test("should return custom types when mode is an array", () => {
+			const types = getTypes(["custom1", "custom2", "custom3"]);
+
+			expect(Object.keys(types).sort()).toEqual(
+				["custom1", "custom2", "custom3"].sort(),
+			);
+			expect(types["custom1"]).toEqual({});
+			expect(types["custom2"]).toEqual({});
+			expect(types["custom3"]).toEqual({});
+		});
+
+		test("should return custom types when mode is an object", () => {
+			const customTypes = {
+				type1: {
+					description: "Custom type 1",
+					title: "Type 1",
+					emoji: "🎨",
+				},
+				type2: {
+					description: "Custom type 2",
+					title: "Type 2",
+				},
+			};
+
+			const types = getTypes(customTypes);
+
+			expect(types).toEqual(customTypes);
+		});
+
+		test("should handle empty array", () => {
+			const types = getTypes([]);
+
+			expect(types).toEqual({});
+		});
+
+		test("should handle single type in array", () => {
+			const types = getTypes(["single"]);
+
+			expect(Object.keys(types)).toEqual(["single"]);
+			expect(types["single"]).toEqual({});
+		});
+	});
+});