changelog-machine 1.1.0 → 2.0.0

package/lib/git/command.js

@@ -0,0 +1,39 @@
+import { spawn } from 'node:child_process';
+export class GitError extends Error {
+    exitCode;
+    constructor(message, exitCode = null) {
+        super(message);
+        this.name = 'GitError';
+        this.exitCode = exitCode;
+    }
+}
+export async function git(args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', args, {
+            cwd,
+            shell: false,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: Object.assign({}, process.env, { ['GIT_TERMINAL_PROMPT']: '0' }),
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk;
+        });
+        const context = `git ${args.map((arg) => JSON.stringify(arg)).join(' ')} in ${cwd ?? process.cwd()}`;
+        child.on('error', (error) => {
+            reject(new GitError(`Could not run ${context}: ${error.message}. Check that Git is installed and the working directory exists.`));
+        });
+        child.on('close', (code, signal) => {
+            if (code === 0)
+                resolve(stdout);
+            else
+                reject(new GitError(`${context} failed (${signal ? `signal ${signal}` : `exit ${code}`}): ${stderr.trim() || 'no diagnostic output'}`, code));
+        });
+    });
+}

package/lib/git/commits.d.ts

@@ -0,0 +1,2 @@
+import type { Commit } from '../types.js';
+export declare function readCommits(range: string, cwd?: string): Promise<Commit[]>;

package/lib/git/commits.js

@@ -0,0 +1,27 @@
+import { git } from './command.js';
+export async function readCommits(range, cwd) {
+    const format = '%H%x00%aN%x00%aE%x00%s%x00%b';
+    const fieldsPerCommit = 5;
+    const output = await git([
+        'log',
+        '--reverse',
+        '--topo-order',
+        '--no-merges',
+        '-z',
+        `--format=${format}`,
+        range,
+        '--',
+    ], cwd);
+    if (!output)
+        return [];
+    const fields = output.split('\0');
+    if (fields.pop() !== '' || fields.length % fieldsPerCommit !== 0) {
+        throw new Error('Git returned an invalid NUL-delimited commit log.');
+    }
+    const commits = [];
+    for (let index = 0; index < fields.length; index += fieldsPerCommit) {
+        const [hash, name, email, subject, body] = fields.slice(index, index + fieldsPerCommit);
+        commits.push({ hash, name, email, subject, body });
+    }
+    return commits;
+}

package/lib/git/history.d.ts

@@ -0,0 +1,3 @@
+import type { Release } from '../types.js';
+export declare function getLatestReleaseTag(cwd?: string): Promise<string | undefined>;
+export declare function getReleases(cwd?: string, afterTag?: string): Promise<Release[]>;

package/lib/git/history.js

@@ -0,0 +1,41 @@
+import { readCommits } from './commits.js';
+import { readGitMetadata, readTagsInHistory, resolveBoundary, validateTagChain, } from './refs.js';
+async function readReleaseRanges(tags, cwd, boundary) {
+    const releases = [];
+    for (let index = 0; index < tags.length; index++) {
+        const current = tags[index];
+        const previous = tags[index + 1] ?? (index === tags.length - 1 ? boundary : undefined);
+        releases.push({
+            tag: current.tag,
+            ...(previous ? { previousTag: previous.tag } : {}),
+            commits: await readCommits(previous ? `${previous.hash}..${current.hash}` : current.hash, cwd),
+        });
+    }
+    return releases;
+}
+export async function getLatestReleaseTag(cwd) {
+    const metadata = await readGitMetadata(cwd);
+    const tags = await readTagsInHistory(metadata, cwd, undefined, true);
+    await validateTagChain(tags, cwd);
+    return tags[0]?.tag;
+}
+export async function getReleases(cwd, afterTag) {
+    const metadata = await readGitMetadata(cwd);
+    const boundary = afterTag === undefined
+        ? undefined
+        : await resolveBoundary(afterTag, metadata, cwd);
+    const tags = await readTagsInHistory(metadata, cwd, boundary);
+    await validateTagChain(tags, cwd, boundary);
+    const base = tags[0] ?? boundary;
+    const hasUnreleasedRange = base ? metadata.head !== base.hash : true;
+    const releases = hasUnreleasedRange || afterTag !== undefined
+        ? [
+            {
+                tag: 'Unreleased',
+                ...(base ? { previousTag: base.tag } : {}),
+                commits: await readCommits(base ? `${base.hash}..${metadata.head}` : metadata.head, cwd),
+            },
+        ]
+        : [];
+    return [...releases, ...(await readReleaseRanges(tags, cwd, boundary))];
+}

package/lib/git/refs.d.ts

@@ -0,0 +1,12 @@
+export type VersionTag = {
+    tag: string;
+    hash: string;
+};
+export type GitMetadata = {
+    head: string;
+    tagsByHash: Map<string, string[]>;
+};
+export declare function readGitMetadata(cwd?: string): Promise<GitMetadata>;
+export declare function resolveBoundary(afterTag: string, metadata: GitMetadata, cwd?: string): Promise<VersionTag>;
+export declare function readTagsInHistory(metadata: GitMetadata, cwd?: string, boundary?: VersionTag, decoratedOnly?: boolean): Promise<VersionTag[]>;
+export declare function validateTagChain(tags: VersionTag[], cwd?: string, boundary?: VersionTag): Promise<void>;

package/lib/git/refs.js

@@ -0,0 +1,101 @@
+import { GitError, git } from './command.js';
+import { isVersionTag } from './tags.js';
+async function requireFullHistory(cwd) {
+    if ((await git(['rev-parse', '--is-shallow-repository'], cwd)).trim() === 'true') {
+        throw new Error('Cannot generate releases from a shallow repository. Fetch the full history with git fetch --unshallow (including tags), then retry.');
+    }
+}
+async function readTagRefs(cwd) {
+    const output = await git([
+        'for-each-ref',
+        '--format=%(refname:strip=2)%00%(objecttype)%00%(objectname)%00%(*objectname)%00',
+        'refs/tags/',
+    ], cwd);
+    const tagsByHash = new Map();
+    const fields = output.split('\0');
+    if (fields.at(-1) === '')
+        fields.pop();
+    for (let index = 0; index + 3 < fields.length; index += 4) {
+        const [rawTag, rawType, rawObjectHash, rawPeeledHash] = fields.slice(index, index + 4);
+        const tag = rawTag.trim();
+        const type = rawType.trim();
+        const hash = type === 'tag' ? rawPeeledHash.trim() : rawObjectHash.trim();
+        if (!tag || !hash || !isVersionTag(tag))
+            continue;
+        const names = tagsByHash.get(hash) ?? [];
+        names.push(tag);
+        tagsByHash.set(hash, names);
+    }
+    return tagsByHash;
+}
+export async function readGitMetadata(cwd) {
+    await requireFullHistory(cwd);
+    const [head, tagsByHash] = await Promise.all([
+        git(['rev-parse', '--verify', 'HEAD^{commit}'], cwd).then((value) => value.trim()),
+        readTagRefs(cwd),
+    ]);
+    return { head, tagsByHash };
+}
+async function isAncestor(older, newer, cwd) {
+    try {
+        await git(['merge-base', '--is-ancestor', older, newer], cwd);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof GitError && error.exitCode === 1)
+            return false;
+        throw error;
+    }
+}
+export async function resolveBoundary(afterTag, metadata, cwd) {
+    if (!isVersionTag(afterTag))
+        throw new Error(`Invalid version tag: ${afterTag}`);
+    const found = [...metadata.tagsByHash].find(([, names]) => names.includes(afterTag));
+    if (!found)
+        throw new Error(`Release boundary tag not found: ${afterTag}`);
+    const boundary = { tag: afterTag, hash: found[0] };
+    if (!(await isAncestor(boundary.hash, metadata.head, cwd))) {
+        throw new Error(`Release boundary tag is not reachable from HEAD: ${afterTag}`);
+    }
+    return boundary;
+}
+export async function readTagsInHistory(metadata, cwd, boundary, decoratedOnly = false) {
+    const args = ['rev-list', '--topo-order'];
+    if (decoratedOnly)
+        args.push('--simplify-by-decoration');
+    args.push(metadata.head);
+    if (boundary)
+        args.push(`^${boundary.hash}`);
+    const output = await git(args, cwd);
+    const tags = [];
+    const encountered = new Set();
+    const hashes = output.trim().split('\n');
+    if (boundary)
+        hashes.push(boundary.hash);
+    for (const hash of hashes) {
+        if (!hash || encountered.has(hash))
+            continue;
+        encountered.add(hash);
+        const names = metadata.tagsByHash.get(hash);
+        if (!names?.length)
+            continue;
+        if (names.length > 1) {
+            throw new Error(`Ambiguous release tags point to the same commit: ${names.join(', ')}.`);
+        }
+        if (hash !== boundary?.hash)
+            tags.push({ tag: names[0], hash });
+    }
+    return tags;
+}
+export async function validateTagChain(tags, cwd, boundary) {
+    for (let index = 1; index < tags.length; index++) {
+        if (!(await isAncestor(tags[index].hash, tags[index - 1].hash, cwd))) {
+            throw new Error(`Ambiguous release tags: ${tags[index - 1].tag} and ${tags[index].tag} are not ancestors of one another. Release tags must form a single ancestry chain.`);
+        }
+    }
+    if (boundary &&
+        tags.length &&
+        !(await isAncestor(boundary.hash, tags.at(-1).hash, cwd))) {
+        throw new Error(`Ambiguous release tags: ${boundary.tag} and ${tags.at(-1).tag} are not ancestors of one another. Release tags must form a single ancestry chain.`);
+    }
+}

package/lib/git/remote.d.ts

@@ -0,0 +1 @@
+export declare function getRepositoryUrl(cwd?: string): Promise<string | undefined>;

package/lib/git/remote.js

@@ -0,0 +1,59 @@
+import { GitError, git } from './command.js';
+const remoteWhitespace = /\s/;
+const supportedRemoteUrlScheme = /^(https|ssh):\/\//i;
+const scpStyleRemote = /^(?:[^@/:]+@)?([^/:]+):(.+)$/;
+const surroundingPathSlashes = /^\/+|\/+$/g;
+const gitPathSuffix = /\.git$/;
+const repositoryPathWithAtLeastTwoSegments = /^[^/]+(?:\/[^/]+)+$/;
+const queryOrFragmentMarker = /[?#]/;
+const supportedRepositoryHosts = ['github.com', 'gitlab.com', 'bitbucket.org'];
+async function readOriginRemote(cwd) {
+    try {
+        return (await git(['config', '--get', 'remote.origin.url'], cwd)).trim();
+    }
+    catch (error) {
+        if (error instanceof GitError && error.exitCode === 1)
+            return undefined;
+        throw error;
+    }
+}
+function parseRemoteHostAndPath(remote) {
+    if (supportedRemoteUrlScheme.test(remote)) {
+        try {
+            const url = new URL(remote);
+            if (url.search || url.hash)
+                return undefined;
+            return { host: url.hostname.toLowerCase(), path: url.pathname };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const match = scpStyleRemote.exec(remote);
+    if (!match)
+        return undefined;
+    const [, host, path] = match;
+    return { host: host.toLowerCase(), path };
+}
+function isValidRepositoryPath(path) {
+    const hasTraversalSegment = path
+        .split('/')
+        .some((segment) => segment === '.' || segment === '..');
+    return (repositoryPathWithAtLeastTwoSegments.test(path) &&
+        !queryOrFragmentMarker.test(path) &&
+        !hasTraversalSegment);
+}
+export async function getRepositoryUrl(cwd) {
+    const remote = await readOriginRemote(cwd);
+    if (!remote || remoteWhitespace.test(remote))
+        return undefined;
+    const repository = parseRemoteHostAndPath(remote);
+    if (!repository || !supportedRepositoryHosts.includes(repository.host))
+        return undefined;
+    const path = repository.path
+        .replace(surroundingPathSlashes, '')
+        .replace(gitPathSuffix, '');
+    if (!isValidRepositoryPath(path))
+        return undefined;
+    return `https://${repository.host}/${path}`;
+}

package/lib/git/tags.d.ts

@@ -0,0 +1 @@
+export declare function isVersionTag(tag: string): boolean;

package/lib/git/tags.js

@@ -0,0 +1,27 @@
+const numericIdentifier = /^(0|[1-9]\d*)$/;
+const allowedIdentifierCharacters = /^[A-Za-z0-9-]+$/;
+const onlyDigits = /^\d+$/;
+function validPrerelease(value) {
+    return value
+        .split('.')
+        .every((identifier) => allowedIdentifierCharacters.test(identifier) &&
+        (!onlyDigits.test(identifier) || numericIdentifier.test(identifier)));
+}
+function validBuild(value) {
+    return value
+        .split('.')
+        .every((identifier) => allowedIdentifierCharacters.test(identifier));
+}
+export function isVersionTag(tag) {
+    const version = tag.startsWith('v') ? tag.slice(1) : tag;
+    const [release, build, extraBuild] = version.split('+');
+    if (extraBuild !== undefined || (build !== undefined && !validBuild(build)))
+        return false;
+    const prereleaseStart = release.indexOf('-');
+    const core = prereleaseStart < 0 ? release : release.slice(0, prereleaseStart);
+    const parts = core.split('.');
+    if (parts.length !== 3 ||
+        !parts.every((part) => numericIdentifier.test(part)))
+        return false;
+    return (prereleaseStart < 0 || validPrerelease(release.slice(prereleaseStart + 1)));
+}

package/lib/index.d.ts

@@ -1 +1,8 @@
-export * from './core/markdown';
+export { renderMarkdown } from './changelog/render.js';
+export { parseCommit, recommendedBump } from './commits/parse.js';
+export { resolveContributors } from './contributors/resolve.js';
+export { getLatestReleaseTag, getReleases } from './git/history.js';
+export { getRepositoryUrl } from './git/remote.js';
+export type { Commit, ContributorProfile, Options, ParsedCommit, Release, } from './types.js';
+export type { VersionPlan } from './version/plan.js';
+export { planVersion } from './version/plan.js';

package/lib/index.js

@@ -1,13 +1,6 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./core/markdown"), exports);
+export { renderMarkdown } from './changelog/render.js';
+export { parseCommit, recommendedBump } from './commits/parse.js';
+export { resolveContributors } from './contributors/resolve.js';
+export { getLatestReleaseTag, getReleases } from './git/history.js';
+export { getRepositoryUrl } from './git/remote.js';
+export { planVersion } from './version/plan.js';

package/lib/types.d.ts

@@ -0,0 +1,31 @@
+export interface Commit {
+    hash: string;
+    name: string;
+    email: string;
+    subject: string;
+    body: string;
+}
+export interface ParsedCommit extends Commit {
+    type: string;
+    scope?: string;
+    description: string;
+    breaking: boolean;
+    breakingNotes: string[];
+    pr?: string;
+}
+export interface Release {
+    tag: string;
+    previousTag?: string;
+    commits: Commit[];
+}
+export interface ContributorProfile {
+    username: string;
+    url: string;
+}
+export interface Options {
+    cwd?: string;
+    repositoryUrl?: string;
+    includeNonConventional?: boolean;
+    contributors?: Readonly<Record<string, ContributorProfile>>;
+    output?: string;
+}

package/lib/types.js

@@ -0,0 +1 @@
+export {};

package/lib/version/json.d.ts

@@ -0,0 +1,5 @@
+export type JsonObject = Record<string, unknown>;
+export declare function isObject(value: unknown): value is JsonObject;
+export declare function parseObject(text: string, path: string): JsonObject;
+export declare function formatJson(value: JsonObject, original: string): string;
+export declare function readOptionalFile(path: string): Promise<string | undefined>;

package/lib/version/json.js

@@ -0,0 +1,35 @@
+import { readFile } from 'node:fs/promises';
+const jsonIndentPattern = /(?:\r?\n)([\t ]+)"/;
+const newlinePattern = /\n/g;
+export function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function parseObject(text, path) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        throw new Error(`Invalid JSON in ${path}. Fix the file before planning a version bump.`);
+    }
+    if (!isObject(value)) {
+        throw new Error(`Expected a JSON object in ${path}. Fix the file before planning a version bump.`);
+    }
+    return value;
+}
+export function formatJson(value, original) {
+    const newline = original.includes('\r\n') ? '\r\n' : '\n';
+    const indent = original.match(jsonIndentPattern)?.[1];
+    const content = JSON.stringify(value, null, indent).replace(newlinePattern, newline);
+    return content + (original.endsWith('\n') ? newline : '');
+}
+export async function readOptionalFile(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}

package/lib/version/lockfiles.d.ts

@@ -0,0 +1,3 @@
+import type { VersionPlan } from './plan.js';
+export declare function readLockfiles(cwd: string): Promise<VersionPlan['files']>;
+export declare function updateLockfile(path: string, content: string, next: string): string;

package/lib/version/lockfiles.js

@@ -0,0 +1,44 @@
+import { resolve } from 'node:path';
+import { formatJson, isObject, parseObject, readOptionalFile } from './json.js';
+export async function readLockfiles(cwd) {
+    const lockNames = [
+        'package-lock.json',
+        'npm-shrinkwrap.json',
+        'pnpm-lock.yaml',
+        'yarn.lock',
+    ];
+    const lockTexts = await Promise.all(lockNames.map((name) => readOptionalFile(resolve(cwd, name))));
+    if (lockTexts[0] !== undefined && lockTexts[1] !== undefined) {
+        throw new Error('Both package-lock.json and npm-shrinkwrap.json exist. Remove the unused lockfile to resolve ambiguity before bumping.');
+    }
+    const unsupported = lockNames.filter((_, index) => index >= 2 && lockTexts[index] !== undefined);
+    if (unsupported.length) {
+        throw new Error(`Unsupported lockfile: ${unsupported.join(', ')}. Update it with its package manager instead; only npm lockfiles are supported.`);
+    }
+    const files = [];
+    for (let index = 0; index < 2; index++) {
+        const content = lockTexts[index];
+        if (content !== undefined)
+            files.push({ path: resolve(cwd, lockNames[index]), content });
+    }
+    return files;
+}
+export function updateLockfile(path, content, next) {
+    const lockfile = parseObject(content, path);
+    if (![1, 2, 3].includes(lockfile.lockfileVersion)) {
+        throw new Error(`Unsupported lockfileVersion in ${path}; expected npm lockfile version 1, 2, or 3.`);
+    }
+    if (typeof lockfile.version !== 'string') {
+        throw new Error(`Malformed ${path}: missing root version. Regenerate the lockfile with npm.`);
+    }
+    if (lockfile.packages !== undefined || lockfile.lockfileVersion !== 1) {
+        if (!isObject(lockfile.packages) ||
+            !isObject(lockfile.packages['']) ||
+            typeof lockfile.packages[''].version !== 'string') {
+            throw new Error(`Malformed ${path}: missing packages[''].version. Regenerate the lockfile with npm.`);
+        }
+        lockfile.packages[''].version = next;
+    }
+    lockfile.version = next;
+    return formatJson(lockfile, content);
+}

package/lib/version/plan.d.ts

@@ -0,0 +1,11 @@
+import type { Commit } from '../types.js';
+export interface VersionPlan {
+    current: string;
+    next?: string;
+    bump?: 'major' | 'minor' | 'patch';
+    files: {
+        path: string;
+        content: string;
+    }[];
+}
+export declare function planVersion(commits: Commit[], latestTag: string | undefined, cwd?: string): Promise<VersionPlan>;

package/lib/version/plan.js

@@ -0,0 +1,51 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { recommendedBump } from '../commits/parse.js';
+import { formatJson, parseObject } from './json.js';
+import { readLockfiles, updateLockfile } from './lockfiles.js';
+const stableVersionPattern = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+const tagPrefixPattern = /^v/;
+function readCurrentVersion(manifest) {
+    const current = manifest.version;
+    if (typeof current !== 'string' || !stableVersionPattern.test(current)) {
+        throw new Error('package.json version must be stable semver (for example 1.2.3); prerelease and build versions are unsupported.');
+    }
+    return current;
+}
+function validateLatestTag(latestTag, current) {
+    if (latestTag !== undefined &&
+        latestTag.replace(tagPrefixPattern, '') !== current) {
+        throw new Error(`Latest tag ${JSON.stringify(latestTag)} does not match package.json version ${current}. ` +
+            'Tag the current release or restore package.json and its lockfile to the latest tagged version before retrying; refusing a repeated inferred bump.');
+    }
+}
+function bumpVersion(current, bump) {
+    const parts = current.split('.').map((part) => BigInt(part));
+    const bumpIndex = { major: 0, minor: 1, patch: 2 }[bump];
+    parts[bumpIndex] += BigInt(1);
+    for (let index = bumpIndex + 1; index < parts.length; index++)
+        parts[index] = BigInt(0);
+    return parts.join('.');
+}
+export async function planVersion(commits, latestTag, cwd = process.cwd()) {
+    const packagePath = resolve(cwd, 'package.json');
+    const packageText = await readFile(packagePath, 'utf8');
+    const manifest = parseObject(packageText, packagePath);
+    const current = readCurrentVersion(manifest);
+    validateLatestTag(latestTag, current);
+    const bump = recommendedBump(commits);
+    if (!bump)
+        return { current, files: [] };
+    const next = bumpVersion(current, bump);
+    const lockfiles = await readLockfiles(cwd);
+    const files = lockfiles.map(({ path, content }) => ({
+        path,
+        content: updateLockfile(path, content, next),
+    }));
+    manifest.version = next;
+    files.unshift({
+        path: packagePath,
+        content: formatJson(manifest, packageText),
+    });
+    return { current, next, bump, files };
+}

package/package.json

@@ -1,60 +1,52 @@
 {
   "name": "changelog-machine",
-  "displayName": "Changelog Machine",
-  "version": "1.1.0",
-  "description": "Changelog generator based on Git commit messages and tags",
+  "version": "2.0.0",
+  "description": "Minimal, dependency-free conventional changelog and version generator",
+  "type": "module",
   "main": "./lib/index.js",
-  "module": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js"
+    }
+  },
   "bin": {
     "changelog-machine": "./bin/cli.js"
   },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "jest",
-    "lint": "eslint -c .eslintrc.json --ext .ts ./src/**/*.ts",
-    "changelog": "ts-node src/cli/index.ts --config changelog.config.json",
-    "prepublish": "npm run build",
-    "version": "npm run changelog && git add CHANGELOG.md"
-  },
   "files": [
-    "lib/"
-  ],
-  "keywords": [
-    "Changelog",
-    "Generator"
+    "lib",
+    "bin",
+    "LICENSE.md"
   ],
   "engines": {
-    "node": ">=4.2.0"
+    "node": ">=24"
   },
-  "author": {
-    "name": "Philipp Kief",
-    "email": "philipp.kief@gmx.de",
-    "url": "https://pkief.github.io"
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "tsc --noEmit && node --import ./scripts/test-loader.js --test src/*/*.test.ts",
+    "lint": "biome check src scripts",
+    "changelog": "npm run build && node bin/cli.js --full",
+    "prepack": "npm run build"
   },
-  "funding": "https://github.com/sponsors/pkief",
+  "keywords": [
+    "changelog",
+    "conventional-commits",
+    "git"
+  ],
+  "author": "Philipp Kief <philipp.kief@gmx.de>",
   "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/PKief/changelog-machine/issues"
-  },
-  "homepage": "https://github.com/PKief/changelog-machine/blob/main/README.md",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/PKief/changelog-machine.git"
   },
-  "devDependencies": {
-    "@types/jest": "^27.4.0",
-    "@types/minimist": "^1.2.2",
-    "@typescript-eslint/eslint-plugin": "^5.4.0",
-    "@typescript-eslint/parser": "^5.4.0",
-    "eslint": "^8.3.0",
-    "eslint-config-prettier": "^8.3.0",
-    "eslint-plugin-prettier": "^4.0.0",
-    "jest": "^27.5.0",
-    "ts-jest": "^27.1.3",
-    "ts-node": "^10.4.0",
-    "typescript": "^4.5.5"
+  "bugs": {
+    "url": "https://github.com/PKief/changelog-machine/issues"
   },
-  "dependencies": {
-    "minimist": "^1.2.5"
+  "funding": "https://github.com/sponsors/pkief",
+  "devDependencies": {
+    "@biomejs/biome": "^2.6.3",
+    "@types/node": "^24.0.0",
+    "typescript": "^7.0.2"
   }
-}
+}

package/lib/cli/commands/printHelp.d.ts

@@ -1,2 +0,0 @@
-declare const printHelp: () => void;
-export { printHelp };