fix(changelog): make co-authors first-class authors; keep all contributors

Addresses the Copilot review on PR #39:

- Co-authors overwrite (utils.js): instead of storing co-authors in a
  per-author field that a later commit could overwrite, every
  `Co-authored-by` trailer now becomes a first-class entry in the authors
  map (keyed by login). This drops co-authors no more, regardless of how
  many commits an author has, and works whether or not Slack IDs are
  fetched. getCommitCoauthors now returns { login, name, email }.

- getAuthorsWithSlackIds no longer drops contributors. Restored to the
  documented contract (action.yml / PR description): return every author
  and attach `slackId` only when it can be resolved, rather than filtering
  out anyone without an org email or Slack match.

Rebuilt dist.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HvWuyXuTp7HFAExnfjG91b

Author: claude

dist/index.js

@@ -92,79 +92,55 @@ async function fetchGithubOrgUsers({ githubToken, repo }) {
 }
 
 /**
- * Create mapping from GitHub usernames to org member info (name + verified @apify.com email).
+ * Create mapping from GitHub usernames to @apify.com emails.
  *
  * @param {{ githubToken: string, repo?: { owner: string; repo: string } }}
  *
- * @returns {Promise<{ [login: string]: { name: string, email: string | null } }>}
+ * @returns {Promise<{ [login: string]: string }>}
  */
-async function getGitHubLoginToOrgInfoMap({ githubToken, repo }) {
+async function getGitHubLoginToEmailMap({ githubToken, repo }) {
     core.info('Trying to fetch @apify.com email addresses for Apify org members');
     const githubOrgUsers = await fetchGithubOrgUsers({ githubToken, repo });
 
     core.info(`Fetched ${githubOrgUsers.length} Apify org members`);
 
-    return githubOrgUsers.reduce((acc, { login, name, organizationVerifiedDomainEmails }) => {
-        acc[login] = {
-            name,
-            email: organizationVerifiedDomainEmails.length > 0 ? organizationVerifiedDomainEmails[0] : null,
-        };
+    return githubOrgUsers.reduce((acc, { login, organizationVerifiedDomainEmails }) => {
+        acc[login] = organizationVerifiedDomainEmails.length > 0 ? organizationVerifiedDomainEmails[0] : null;
         return acc;
     }, {});
 }
 
 /**
- * Resolve every contributor login (commit author + coauthors) across all commits to a Slack ID.
+ * Enhance authors with Slack IDs matching their email addresses.
  *
- * Logins not present in the GitHub org collaborators list, or without a verified @apify.com email,
- * or without a matching Slack user, are filtered out. This naturally excludes bot accounts and
- * external contributors, and includes everyone who shipped via a `Co-authored-by:` trailer.
+ * If the whole function fails, or some emails cannot be matched, the original authors are returned.
  *
  * @param {string} githubToken
  * @param {string} slackToken
- * @param {{ name: string, email: string, login: string, coauthors?: string[] }[]} authors
+ * @param {array<{ name: string, email: string, login: string }>} authors
  * @param {{ owner: string; repo: string }} repo
  *
- * @returns {Promise<array<{ login: string, name: string, email: string, slackId: string }>>}
+ * @returns {Promise<array<{ name: string, email: string, login: string, slackId?: string }>>}
  */
 async function getAuthorsWithSlackIds(githubToken, slackToken, authors, repo = undefined) {
     if (!authors.length) {
         core.info('No authors to fetch Slack IDs for');
         return authors;
     }
 
-    const githubLoginToOrgInfo = await getGitHubLoginToOrgInfoMap({ githubToken, repo });
+    const githubLoginToEmailMap = await getGitHubLoginToEmailMap({ githubToken, repo });
     const emailToSlackIdMap = await getEmailToSlackIdMap(slackToken);
 
-    // Union of every login mentioned anywhere across the release (primary authors + coauthors).
-    const contributorLogins = new Set();
-    for (const author of authors) {
-        if (author.login) {
-            contributorLogins.add(author.login);
-        }
-        for (const coauthor of author.coauthors ?? []) {
-            contributorLogins.add(coauthor);
-        }
-    }
+    return authors.map((author) => {
+        const slackId = emailToSlackIdMap[githubLoginToEmailMap[author.login] || author.email];
 
-    const result = [];
-    for (const login of contributorLogins) {
-        const orgInfo = githubLoginToOrgInfo[login];
-        if (!orgInfo?.email) {
-            // Not an org member, or org member without a verified @apify.com email. Filtered out.
-            continue;
-        }
-
-        const slackId = emailToSlackIdMap[orgInfo.email];
         if (!slackId) {
-            core.warning(`Slack ID not found for ${login} (${orgInfo.email})`);
-            continue;
+            core.warning(`Slack ID not found for ${author.name} (${author.login} / ${author.email})`);
+            return author;
         }
 
-        result.push({ login, name: orgInfo.name, email: orgInfo.email, slackId });
-    }
-
-    return result;
+        return { ...author, slackId };
+    });
 }
 
 module.exports = {

dist/index.js.map

@@ -130,8 +130,12 @@ async function getChangelogFromPullRequestCommits(octokit, scopes, context) {
         const { login } = commit.author;
         commitMessages.push(message);
 
-        const coauthors = getCommitCoauthors(message);
-        authors.set(login || author.email, { login, ...author, coauthors }); // We want each author only once
+        // Each contributor (the commit author and every `Co-authored-by` trailer) becomes a changelog
+        // author. Keyed by login (falling back to email) so everyone appears exactly once.
+        authors.set(login || author.email, { login, ...author });
+        for (const coauthor of getCommitCoauthors(message)) {
+            authors.set(coauthor.login || coauthor.email, coauthor);
+        }
     }
 
     const { changelog, includedPrNumbers } = await prepareChangeLog(commitMessages, scopes);
@@ -184,8 +188,12 @@ async function getChangelogFromCompareBranches(octokit, context, baseBranch, hea
             const { login } = commit.author;
             commitMessages.push(message);
 
-            const coauthors = getCommitCoauthors(message);
-            authors.set(login || author.email, { login, ...author, coauthors }); // We want each author only once
+            // Each contributor (the commit author and every `Co-authored-by` trailer) becomes a changelog
+            // author. Keyed by login (falling back to email) so everyone appears exactly once.
+            authors.set(login || author.email, { login, ...author });
+            for (const coauthor of getCommitCoauthors(message)) {
+                authors.set(coauthor.login || coauthor.email, coauthor);
+            }
         }
     }
 
@@ -350,49 +358,53 @@ const COAUTHORED_BY_REGEX = /^Co-authored-by: (?<name>.+?) <(?<email>.+?)@(?<ema
 const GITHUB_LOGIN_REGEX = /^[a-zA-Z0-9-]+$/i;
 
 /**
- * Parses the `Co-authored-by` trailers from commit messages.
+ * Parses the `Co-authored-by` trailers from a commit message.
  *
  * @param {string} commitMessage
- * @returns {string[]} list of github logins of the commit co-authors
+ * @returns {{ login: string, name: string, email: string }[]} the commit co-authors, de-duplicated by login
  */
 function getCommitCoauthors(commitMessage) {
     /** @type {RegExpExecArray | null} */
-    let coauthor = null;
-    const coauthors = new Set();
+    let match = null;
+    const coauthorsByLogin = new Map();
 
-    // Reset the regex with `g`
+    // The regex is global (`g` flag), so reset its state before iterating to keep this function idempotent.
     COAUTHORED_BY_REGEX.lastIndex = 0;
 
     // eslint-disable-next-line no-cond-assign
-    while ((coauthor = COAUTHORED_BY_REGEX.exec(commitMessage)) != null) {
-        const { name, email, emailDomain } = coauthor.groups;
+    while ((match = COAUTHORED_BY_REGEX.exec(commitMessage)) != null) {
+        const { name, email, emailDomain } = match.groups;
+        const trimmedName = name && name.trim();
 
+        let login = null;
         if (emailDomain === 'users.noreply.github.com' && email && email.includes('+')) {
             const [, maybeLogin] = email.split('+');
 
             if (GITHUB_LOGIN_REGEX.test(maybeLogin)) {
-                coauthors.add(maybeLogin);
-
-                continue;
+                login = maybeLogin;
             }
         }
 
-        const trimmedName = name && name.trim();
-
-        if (trimmedName && GITHUB_LOGIN_REGEX.test(trimmedName)) {
-            coauthors.add(trimmedName);
+        if (!login && trimmedName && GITHUB_LOGIN_REGEX.test(trimmedName)) {
+            login = trimmedName;
+        }
 
+        if (!login) {
+            // eslint-disable-next-line no-console
+            console.warn(`WARNING: could not parse the login from the "Co-authored-by" trailer of a commit message`, {
+                name,
+                email: `${email}@${emailDomain}`,
+            });
             continue;
         }
 
-        // eslint-disable-next-line no-console
-        console.warn(`WARNING: could not parse the login from the "Co-authored-by" trailer of a commit message`, {
-            name,
-            email: `${email}@${emailDomain}`,
-        });
+        // Keep the first occurrence of each login.
+        if (!coauthorsByLogin.has(login)) {
+            coauthorsByLogin.set(login, { login, name: trimmedName, email: `${email}@${emailDomain}` });
+        }
     }
 
-    return Array.from(coauthors);
+    return Array.from(coauthorsByLogin.values());
 }
 
 module.exports = {