@chamoji/core 0.1.0 → 0.2.0

package/dist/changelog.d.ts

@@ -1,4 +1,4 @@
-import type { ChamojiConfig, Changelog } from './types.js';
+import type { ChamojiConfig, Changelog, CommitClassifier } from './types.js';
 export type BuildChangelogOptions = {
     cwd: string;
     config: ChamojiConfig;
@@ -10,5 +10,15 @@ export type BuildChangelogOptions = {
     release?: string;
     /** `YYYY-MM-DD`; defaults to the current UTC date. */
     today?: string;
+    /**
+     * Optional AI step for commits no gitmoji, type or wording rule could
+     * sort. It never sees or overrides the others.
+     */
+    classify?: CommitClassifier;
+    /**
+     * Which commits `classify` sees: every release (default), or only the
+     * unreleased section, which is all `next-version` needs.
+     */
+    classifyReleases?: 'all' | 'unreleased';
 };
 export declare function buildChangelog(options: BuildChangelogOptions): Promise<Changelog>;

package/dist/changelog.js

@@ -1,5 +1,6 @@
 import semver from 'semver';
 import { assertGitRepo, assertRevision, getRemoteWebUrl, listReleaseTags, readCommits, } from './git.js';
+import { getGitmoji } from './gitmojis.js';
 import { groupCommits } from './group.js';
 import { parseCommit } from './parse.js';
 import { bumpFor, nextVersion } from './version.js';
@@ -24,26 +25,20 @@ export async function buildChangelog(options) {
     if (from && !tags.some(tag => tag.name === from)) {
         throw new Error(`Unknown release tag for --from: ${from}`);
     }
-    const makeRelease = (fields, raw, isUnreleased) => {
-        const commits = raw.map(parseCommit);
-        const bump = bumpFor(commits);
-        return {
-            ...fields,
-            bump,
-            nextVersion: isUnreleased ? nextVersion(fields.previousTag, bump) : null,
-            groups: groupCommits(commits, config.groups),
-        };
-    };
-    const releases = [];
+    const pending = [];
     const latest = tags[0]?.name ?? null;
     const unreleased = await readCommits(cwd, latest ? `${latest}..${to}` : to);
     if (unreleased.length > 0) {
-        releases.push(makeRelease({
-            version: release ?? 'Unreleased',
-            tag: release ? futureTag(release, latest) : null,
-            previousTag: latest,
-            date: release ? today : null,
-        }, unreleased, true));
+        pending.push({
+            fields: {
+                version: release ?? 'Unreleased',
+                tag: release ? futureTag(release, latest) : null,
+                previousTag: latest,
+                date: release ? today : null,
+            },
+            commits: unreleased.map(parseCommit),
+            isUnreleased: true,
+        });
     }
     for (const [index, tag] of tags.entries()) {
         if (tag.name === from) {
@@ -51,14 +46,52 @@ export async function buildChangelog(options) {
         }
         const previousTag = tags[index + 1]?.name ?? null;
         const raw = await readCommits(cwd, previousTag ? `${previousTag}..${tag.name}` : tag.name);
-        releases.push(makeRelease({
-            version: tag.name,
-            tag: tag.name,
-            previousTag,
-            date: tag.date.slice(0, 10) || null,
-        }, raw, false));
+        pending.push({
+            fields: {
+                version: tag.name,
+                tag: tag.name,
+                previousTag,
+                date: tag.date.slice(0, 10) || null,
+            },
+            commits: raw.map(parseCommit),
+            isUnreleased: false,
+        });
+    }
+    if (options.classify) {
+        const scope = options.classifyReleases === 'unreleased'
+            ? pending.filter(item => item.isUnreleased)
+            : pending;
+        await applyClassifier(options.classify, scope.flatMap(item => item.commits));
     }
+    const releases = pending.map(({ fields, commits, isUnreleased }) => {
+        const bump = bumpFor(commits);
+        return {
+            ...fields,
+            bump,
+            nextVersion: isUnreleased ? nextVersion(fields.previousTag, bump) : null,
+            groups: groupCommits(commits, config.groups),
+        };
+    });
     const repositoryUrl = config.repositoryUrl ?? (await getRemoteWebUrl(cwd));
     return { ...(repositoryUrl ? { repositoryUrl } : {}), releases };
 }
+/**
+ * Runs the classifier on unsorted commits and applies its picks in place.
+ * Unknown codes are ignored, and so is `boom`: only authors declare breaking
+ * changes.
+ */
+async function applyClassifier(classify, commits) {
+    const unsorted = commits.filter(commit => commit.gitmojiSource === null);
+    if (unsorted.length === 0) {
+        return;
+    }
+    const picks = await classify(unsorted);
+    for (const commit of unsorted) {
+        const code = picks.get(commit.hash);
+        if (code && code !== 'boom' && getGitmoji(code)) {
+            commit.gitmoji = code;
+            commit.gitmojiSource = 'ai';
+        }
+    }
+}
 //# sourceMappingURL=changelog.js.map

package/dist/config.js

@@ -16,7 +16,6 @@ export const DEFAULT_GROUP_CONFIG = [
             'white_check_mark',
             'construction_worker',
             'chart_with_upwards_trend',
-            'heavy_plus_sign',
             'loud_sound',
             'globe_with_meridians',
             'camera_flash',
@@ -40,9 +39,6 @@ export const DEFAULT_GROUP_CONFIG = [
             'zap',
             'lipstick',
             'rotating_light',
-            'arrow_down',
-            'arrow_up',
-            'pushpin',
             'recycle',
             'wrench',
             'rewind',
@@ -72,7 +68,7 @@ export const DEFAULT_GROUP_CONFIG = [
     {
         group: 'removed',
         label: 'Removed',
-        emojis: ['fire', 'heavy_minus_sign', 'mute', 'coffin'],
+        emojis: ['fire', 'mute', 'coffin'],
     },
     {
         group: 'fixed',
@@ -95,6 +91,18 @@ export const DEFAULT_GROUP_CONFIG = [
         label: 'Security',
         emojis: ['lock', 'closed_lock_with_key', 'passport_control'],
     },
+    {
+        group: 'dependencies',
+        label: 'Dependencies',
+        emojis: [
+            'arrow_up',
+            'arrow_down',
+            'pushpin',
+            'heavy_plus_sign',
+            'heavy_minus_sign',
+        ],
+        collapse: true,
+    },
     {
         group: 'useless',
         label: 'Useless',

package/dist/group.js

@@ -26,6 +26,7 @@ export function groupCommits(commits, config) {
         .map(item => ({
         group: item.group,
         label: item.label,
+        ...(item.collapse ? { collapse: true } : {}),
         commits: buckets.get(item.group),
     }));
 }

package/dist/infer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Guesses a gitmoji for a plain commit subject ("Add x", "Fix y") so repos
+ * that use neither gitmoji nor Conventional Commits still get sections.
+ * Rules are checked in order; the first match wins. Verbs are matched as
+ * whole word forms ("fix", "fixes", "fixed", "fixing"), so "Fixture" or
+ * "Dropdown" don't count, and topic words only count near the start.
+ */
+export declare function inferGitmoji(subject: string): string | null;

package/dist/infer.js

@@ -0,0 +1,94 @@
+/**
+ * Guesses a gitmoji for a plain commit subject ("Add x", "Fix y") so repos
+ * that use neither gitmoji nor Conventional Commits still get sections.
+ * Rules are checked in order; the first match wins. Verbs are matched as
+ * whole word forms ("fix", "fixes", "fixed", "fixing"), so "Fixture" or
+ * "Dropdown" don't count, and topic words only count near the start.
+ */
+/** A version-like token: `1.2.3`, `v4`, `^7.0`. */
+const VERSION = String.raw `[~^]?v?\d[\w.-]*`;
+const RULES = [
+    // Version-only and release commits (hidden by default).
+    [/^v?\d+\.\d+\.\d+\S*$/, 'bookmark'],
+    [
+        /^(?:release|releasing|prepare release(?: for)?|bump version(?: to)?)\s+v?\d|^(?:release|bump version)$/i,
+        'bookmark',
+    ],
+    [/^(?:initial commit|init)\b/i, 'tada'],
+    [/^\[breaking\]/i, 'boom'],
+    [/^(?:require|drop support for)\s+node(?:\.js)?\s*\d+/i, 'boom'],
+    // Dependency updates: Dependabot, Renovate and hand-written ones.
+    [/^pin\s+(?:dev-?)?dependenc(?:y|ies)\b/i, 'pushpin'],
+    [
+        /^(?:bump|update|upgrade)\s+(?:all\s+)?(?:non-major\s+|minor\s+|patch\s+)?(?:dev[- ]?)?(?:dependencies|dependency|deps)\b/i,
+        'arrow_up',
+    ],
+    [/^lock\s?file maintenance\b/i, 'arrow_up'],
+    [/^bump\s+the\s+\S+\s+group\b/i, 'arrow_up'],
+    [/^update\s+\S+\s+(?:action|monorepo|docker tag|digest)\b/i, 'arrow_up'],
+    [
+        new RegExp(String.raw `^(?:bump|update|upgrade|pin)\s+\S+\s+from\s+${VERSION}\s+to\s+${VERSION}`, 'i'),
+        'arrow_up',
+    ],
+    [/^bump\s+`?[@\w./-]+`?\s*$/i, 'arrow_up'],
+    [
+        new RegExp(String.raw `^upgrad(?:e|es|ed|ing)\b.*\s${VERSION}`, 'i'),
+        'arrow_up',
+    ],
+    // Topics, only when they are what the subject is about.
+    [/^(?:\w+\s+){0,2}(?:the\s+)?(?:readme|docs?|documentation)\b/i, 'memo'],
+    [/^document(?:s|ed|ing)?\b/i, 'memo'],
+    [/^(?:fix(?:es|ed)?\s+(?:an?\s+|the\s+)?typos?|typos?)\b/i, 'pencil2'],
+    [/^fix(?:es|ed|ing)?\s+(?:the\s+)?ci\b/i, 'green_heart'],
+    [
+        /^(?:add|adds|added|improve|update|fix)\s+(?:more\s+)?tests?\b|^tests?\b/i,
+        'white_check_mark',
+    ],
+    [
+        /^fix(?:es|ed|ing)?\b.*\b(?:security|vulnerabilit(?:y|ies)|cve-\d+)/i,
+        'lock',
+    ],
+    [/^(?:security|cve-\d+)\b/i, 'lock'],
+    [
+        /^(?:improve|boost|increase)\s+(?:\w+\s+)?(?:performance|perf|speed)\b|^(?:optimi[sz]e[sd]?|speed\s+up)\b|^make\b.*\bfaster\b/i,
+        'zap',
+    ],
+    [/^(?:minor\s+)?(?:code\s+style|minor\s+code|style)\s+tweaks?\b/i, 'art'],
+    [/^add(?:s|ed)?\s+missing\b/i, 'bug'],
+    // The leading verb.
+    [
+        /^(?:add(?:s|ed|ing)?|implement(?:s|ed|ing)?|introduc(?:e|es|ed|ing)|creat(?:e|es|ed|ing)|support(?:s|ed|ing)?|export(?:s|ed|ing)?|allow(?:s|ed|ing)?|enabl(?:e|es|ed|ing))\b/i,
+        'sparkles',
+    ],
+    [
+        /^(?:fix(?:es|ed|ing)?|resolv(?:e|es|ed|ing)|correct(?:s|ed|ing)?|repair(?:s|ed|ing)?|hotfix(?:es|ed)?)\b/i,
+        'bug',
+    ],
+    [
+        /^(?:remov(?:e|es|ed|ing)|delet(?:e|es|ed|ing)|drop(?:s|ped|ping)?)\b/i,
+        'fire',
+    ],
+    [/^deprecat(?:e|es|ed|ing)\b/i, 'wastebasket'],
+    [/^(?:renam(?:e|es|ed|ing)|mov(?:e|es|ed|ing))\b/i, 'truck'],
+    [
+        /^(?:refactor(?:s|ed|ing)?|clean(?:s|ed|ing)?|cleanup|simplif(?:y|ies|ied|ying)|restructur(?:e|es|ed|ing)|reorganiz(?:e|es|ed|ing))\b/i,
+        'recycle',
+    ],
+    [/^downgrad(?:e|es|ed|ing)\b/i, 'arrow_down'],
+    [
+        /^(?:updat(?:e|es|ed|ing)|upgrad(?:e|es|ed|ing)|improv(?:e|es|ed|ing)|chang(?:e|es|ed|ing)|tweak(?:s|ed|ing)?|meta|use|replac(?:e|es|ed|ing)|rewrit(?:e|es|ing|ten)|migrat(?:e|es|ed|ing)|make|ensure|switch(?:es|ed|ing)?)\b/i,
+        'wrench',
+    ],
+];
+/** Prefixes that say nothing about the change, like "Close #14 PR: ". */
+const NOISE_PREFIX = /^(?:close[sd]?\s+#\d+\s+pr:\s*)/i;
+export function inferGitmoji(subject) {
+    const text = subject.trim().replace(NOISE_PREFIX, '');
+    for (const [pattern, code] of RULES) {
+        if (pattern.test(text)) {
+            return code;
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=infer.js.map

package/dist/parse.js

@@ -1,4 +1,5 @@
 import { findGitmoji, normalizeEmoji } from './gitmojis.js';
+import { inferGitmoji } from './infer.js';
 /** Conventional Commits types we recognize, and the gitmoji each implies. */
 const TYPE_TO_GITMOJI = {
     feat: 'sparkles',
@@ -12,7 +13,13 @@ const TYPE_TO_GITMOJI = {
     ci: 'construction_worker',
     chore: 'wrench',
     revert: 'rewind',
+    release: 'bookmark',
+    wip: 'construction',
+    deps: 'arrow_up',
+    security: 'lock',
 };
+/** Conventional scopes that mean "dependency update" under any type. */
+const DEPENDENCY_SCOPES = new Set(['deps', 'deps-dev', 'dependencies']);
 const CONVENTIONAL_PREFIX = /^(\w+)(?:\(([^)]+)\))?(!)?:\s*/;
 const GITMOJI_CLI_SCOPE = /^\(([^)]+)\):\s*/;
 const BREAKING_FOOTER = /^BREAKING[ -]CHANGE:/m;
@@ -27,6 +34,7 @@ export function parseCommit(raw) {
             ...original,
             body: raw.body,
             gitmoji: 'rewind',
+            gitmojiSource: 'rule',
             type: null,
             description: `Revert "${original.description}"`,
             breaking: BREAKING_FOOTER.test(raw.body),
@@ -46,9 +54,11 @@ export function parseCommit(raw) {
         text = text.slice(prefix[0].length);
     }
     let gitmoji = null;
+    let gitmojiSource = null;
     const found = findGitmoji(text);
     if (found) {
         gitmoji = found.code;
+        gitmojiSource = 'gitmoji';
         text = (text.slice(0, found.index) + text.slice(found.index + found.length))
             .replaceAll(/\s{2,}/g, ' ')
             .trim();
@@ -59,12 +69,21 @@ export function parseCommit(raw) {
         text = text.slice(cliScope[0].length);
     }
     if (!gitmoji && type) {
-        gitmoji = TYPE_TO_GITMOJI[type] ?? null;
+        gitmoji =
+            scope && DEPENDENCY_SCOPES.has(scope.toLowerCase())
+                ? 'arrow_up'
+                : (TYPE_TO_GITMOJI[type] ?? null);
+        gitmojiSource = gitmoji ? 'type' : null;
+    }
+    if (!gitmoji) {
+        gitmoji = inferGitmoji(text);
+        gitmojiSource = gitmoji ? 'rule' : null;
     }
     const { trailers: rawTrailers, ...rest } = raw;
     return {
         ...rest,
         gitmoji,
+        gitmojiSource,
         type,
         scope,
         description: text.trim(),

package/dist/render/html.js

@@ -1,4 +1,4 @@
-import { commitLink, emojiFor, issueLink, releaseLink, safeRepositoryUrl, splitIssues, } from './shared.js';
+import { commitLink, DEPENDENCY_EMOJI, emojiFor, issueLink, releaseLink, safeRepositoryUrl, splitIssues, summarizeDependencies, } from './shared.js';
 const ESCAPES = {
     '&': '&',
     '<': '&lt;',
@@ -34,8 +34,13 @@ export function renderHtml(changelog) {
         out.push(`<section id="${version}">`, `<h2>${link ? anchor(link, version) : version}${date}</h2>`);
         for (const group of release.groups) {
             out.push(`<h3>${escapeHtml(group.label)}</h3>`, '<ul>');
-            for (const commit of group.commits) {
-                out.push(`<li>${renderCommit(commit, url)}</li>`);
+            if (group.collapse) {
+                out.push(`<li>${DEPENDENCY_EMOJI} ${escapeHtml(summarizeDependencies(group.commits))}</li>`);
+            }
+            else {
+                for (const commit of group.commits) {
+                    out.push(`<li>${renderCommit(commit, url)}</li>`);
+                }
             }
             out.push('</ul>');
         }

package/dist/render/markdown.js

@@ -1,4 +1,4 @@
-import { commitLink, emojiFor, issueLink, releaseLink, safeRepositoryUrl, splitIssues, } from './shared.js';
+import { commitLink, DEPENDENCY_EMOJI, emojiFor, issueLink, releaseLink, safeRepositoryUrl, splitIssues, summarizeDependencies, } from './shared.js';
 /**
  * Makes commit text inert outside code spans: no raw HTML, and no links or
  * images, since squash-merged PR titles can come from anyone. Backticks are
@@ -27,8 +27,13 @@ export function renderMarkdown(changelog) {
         lines.push(`## ${title}${release.date ? ` - ${release.date}` : ''}`, '');
         for (const group of release.groups) {
             lines.push(`### ${group.label}`, '');
-            for (const commit of group.commits) {
-                lines.push(`- ${renderCommit(commit, url)}`);
+            if (group.collapse) {
+                lines.push(`- ${DEPENDENCY_EMOJI} ${escapeMarkdown(summarizeDependencies(group.commits))}`);
+            }
+            else {
+                for (const commit of group.commits) {
+                    lines.push(`- ${renderCommit(commit, url)}`);
+                }
             }
             lines.push('');
         }

package/dist/render/shared.d.ts

@@ -5,8 +5,20 @@ export declare function safeRepositoryUrl(changelog: Changelog): string | undefi
 export declare function releaseLink(release: Release, url: string | undefined): string | undefined;
 export declare function commitLink(commit: ParsedCommit, url: string): string;
 export declare function issueLink(issue: string, url: string): string;
-/** The commit's gitmoji as a character, `:code:` for retired ones, or ''. */
+/**
+ * The commit's gitmoji as a character, `:code:` for retired ones, or ''.
+ * Gitmojis that chamoji guessed (from wording or AI) are not shown, so plain
+ * histories aren't decorated with emojis their authors never wrote.
+ */
 export declare function emojiFor(commit: ParsedCommit): string;
+/**
+ * One-line summary of a collapsed group of dependency updates, e.g.
+ * `9 dependency updates: jest, vite, … and 2 more`. Names come from
+ * Dependabot/Renovate-style subjects; a Dependabot group PR counts as the
+ * number of updates it bundles.
+ */
+export declare function summarizeDependencies(commits: ParsedCommit[]): string;
+export declare const DEPENDENCY_EMOJI: string;
 /**
  * Splits text into plain parts and `#123` issue references, so renderers can
  * escape the plain parts and link the references.

package/dist/render/shared.js

@@ -19,13 +19,53 @@ export function commitLink(commit, url) {
 export function issueLink(issue, url) {
     return `${url}/issues/${issue}`;
 }
-/** The commit's gitmoji as a character, `:code:` for retired ones, or ''. */
+/**
+ * The commit's gitmoji as a character, `:code:` for retired ones, or ''.
+ * Gitmojis that chamoji guessed (from wording or AI) are not shown, so plain
+ * histories aren't decorated with emojis their authors never wrote.
+ */
 export function emojiFor(commit) {
-    if (!commit.gitmoji) {
+    if (!commit.gitmoji ||
+        (commit.gitmojiSource !== 'gitmoji' && commit.gitmojiSource !== 'type')) {
         return '';
     }
     return getGitmoji(commit.gitmoji)?.emoji ?? `:${commit.gitmoji}:`;
 }
+const DEPENDENCY_NAME = /^(?:bump|update|upgrade|downgrade|pin)\s+(?:the\s+)?(?:(?:dev[- ]?)?dependency\s+)?([@\w./-]+)/i;
+const NOT_A_NAME = /^(?:dependencies|deps|dev|all|minor|patch|major)$/i;
+/** Dependabot grouped updates: "Bump the npm group … with 5 updates". */
+const DEPENDABOT_GROUP = /^bump\s+the\s+\S+\s+group\b.*?\bwith\s+(\d+)\s+updates?\b/i;
+const SHOWN_NAMES = 5;
+/**
+ * One-line summary of a collapsed group of dependency updates, e.g.
+ * `9 dependency updates: jest, vite, … and 2 more`. Names come from
+ * Dependabot/Renovate-style subjects; a Dependabot group PR counts as the
+ * number of updates it bundles.
+ */
+export function summarizeDependencies(commits) {
+    const names = new Set();
+    let updates = 0;
+    for (const commit of commits) {
+        const group = DEPENDABOT_GROUP.exec(commit.description);
+        if (group) {
+            updates += Number(group[1]);
+            continue;
+        }
+        updates++;
+        const name = DEPENDENCY_NAME.exec(commit.description)?.[1];
+        if (name && !NOT_A_NAME.test(name)) {
+            names.add(name);
+        }
+    }
+    const count = `${updates} dependency update${updates === 1 ? '' : 's'}`;
+    if (names.size === 0) {
+        return count;
+    }
+    const shown = [...names].slice(0, SHOWN_NAMES);
+    const more = names.size - shown.length;
+    return `${count}: ${shown.join(', ')}${more > 0 ? ` and ${more} more` : ''}`;
+}
+export const DEPENDENCY_EMOJI = getGitmoji('arrow_up')?.emoji ?? '⬆️';
 /**
  * Splits text into plain parts and `#123` issue references, so renderers can
  * escape the plain parts and link the references.

package/dist/types.d.ts

@@ -16,9 +16,15 @@ export type Trailer = {
     key: string;
     value: string;
 };
+/**
+ * Where a commit's gitmoji came from: written in the message, implied by a
+ * Conventional type, guessed from the wording, or picked by an AI classifier.
+ */
+export type GitmojiSource = 'gitmoji' | 'type' | 'rule' | 'ai' | null;
 export type ParsedCommit = Omit<RawCommit, 'trailers'> & {
     /** Gitmoji code without colons, e.g. `sparkles`. */
     gitmoji: string | null;
+    gitmojiSource: GitmojiSource;
     /** Conventional Commits type, e.g. `feat`. */
     type: string | null;
     scope: string | null;
@@ -34,6 +40,8 @@ export type GroupConfigItem = {
     emojis: string[];
     /** Hidden groups are matched but left out of the output. */
     hidden?: boolean;
+    /** Render the group as one summary line (used for dependency updates). */
+    collapse?: boolean;
 };
 export type GroupConfig = GroupConfigItem[];
 export type ChamojiConfig = {
@@ -43,6 +51,7 @@ export type ChamojiConfig = {
 export type Group = {
     group: string;
     label: string;
+    collapse?: boolean;
     commits: ParsedCommit[];
 };
 export type Release = {
@@ -64,3 +73,8 @@ export type Changelog = {
     repositoryUrl?: string;
     releases: Release[];
 };
+/**
+ * Picks gitmoji codes for commits chamoji could not sort. Returns a map from
+ * commit hash to code, for the commits it is confident about.
+ */
+export type CommitClassifier = (commits: ParsedCommit[]) => Promise<Map<string, string>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chamoji/core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Changelog engine for gitmoji and Conventional Commits",
   "license": "MIT",
   "type": "module",