fix: improve member merge suggestions for split git email profiles (CM-1137)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: skwowet

services/apps/merge_suggestions_worker/src/activities/memberMergeSuggestions.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import uniqBy from 'lodash.uniqby'
 
-import { parseGitHubNoreplyEmail } from '@crowd/common'
+import { parseGitHubNoreplyEmail, parseGitLabNoreplyEmail } from '@crowd/common'
 import { addMemberNoMerge } from '@crowd/data-access-layer/src/member_merge'
 import { MemberField, queryMembers } from '@crowd/data-access-layer/src/members'
 import MemberMergeSuggestionsRepository from '@crowd/data-access-layer/src/old/apps/merge_suggestions_worker/memberMergeSuggestions.repo'
@@ -113,12 +113,18 @@ export async function getMemberMergeSuggestions(
       targetLists.usernameEmail.push({ value })
     }
 
-    // Noreply email -> platform username extraction
-    if (isEmail && verified) {
+    // Noreply identity -> platform username extraction.
+    // Noreply identities may be ingested as type=email or type=username depending on the source,
+    // so we check both.
+    if ((isEmail || isUsername) && verified) {
       const ghUsername = parseGitHubNoreplyEmail(value)
       if (ghUsername) {
         noreplyEmailUsernameMatches.push({ value: ghUsername, platform: PlatformType.GITHUB })
       }
+      const glUsername = parseGitLabNoreplyEmail(value)
+      if (glUsername) {
+        noreplyEmailUsernameMatches.push({ value: glUsername, platform: PlatformType.GITLAB })
+      }
     }
 
     // Fuzzy matches (only for verified & non-numeric)
@@ -214,7 +220,7 @@ export async function getMemberMergeSuggestions(
     },
     {
       // Query 8: Noreply/private email -> username (verified or unverified)
-      matches: uniqBy(noreplyEmailUsernameMatches, 'value'),
+      matches: uniqBy(noreplyEmailUsernameMatches, (m) => `${m.platform}:${m.value}`),
       builder: ({ value, platform }) => ({
         bool: {
           must: [

services/apps/merge_suggestions_worker/src/memberSimilarityCalculator.ts

@@ -1,6 +1,12 @@
 import { get as getLevenshteinDistance } from 'fast-levenshtein'
 
-import { parseGitHubNoreplyEmail } from '@crowd/common'
+import {
+  getEmailLocalPart,
+  isKnownBot,
+  isLocalMachineEmail,
+  parseGitHubNoreplyEmail,
+  parseGitLabNoreplyEmail,
+} from '@crowd/common'
 import {
   IMemberIdentity,
   IMemberOpensearch,
@@ -196,32 +202,87 @@ class MemberSimilarityCalculator {
       for (const identity of member.identities.filter(
         (i) => i.type === MemberIdentityType.USERNAME,
       )) {
+        const clashingIdentity = similarMember.nested_identities.find(
+          (i) =>
+            i.keyword_type === MemberIdentityType.USERNAME &&
+            i.string_platform === identity.platform &&
+            i.keyword_value !== identity.value,
+        )
+
+        if (!clashingIdentity) continue
+
+        // git "usernames" are commit-author emails — a single person commits from many addresses
+        // (work, personal, noreply, machine-local). Different values don't mean different people.
+        // Skip the clash unless the displayName is a bot or placeholder rather than a real identity.
         if (
-          similarMember.nested_identities.some(
-            (i) =>
-              i.keyword_type === MemberIdentityType.USERNAME &&
-              i.string_platform === identity.platform &&
-              i.keyword_value !== identity.value,
-          )
+          identity.platform === PlatformType.GIT &&
+          identity.value.includes('@') &&
+          clashingIdentity.keyword_value?.includes('@') &&
+          !this.isNonIdentityBearingDisplayName(member, similarMember)
         ) {
-          return true
+          continue
         }
+
+        return true
       }
     }
 
     return false
   }
 
-  /**
-   * Checks if a noreply email in one member matches a username in the other (e.g. GitHub noreply email -> GitHub username)
-   * Works bidirectionally: primary email -> similar username, and similar email -> primary username.
-   */
+  // Returns true when either member's displayName is a bot or a generic placeholder rather than
+  // a real person's name — we keep conservative clash detection for these to avoid merging
+  // distinct entities that share the same non-identity string.
+  private static isNonIdentityBearingDisplayName(
+    member: IMemberWithAggregatesForMergeSuggestions,
+    similarMember: IMemberOpensearch,
+  ): boolean {
+    if (member.attributes?.[MemberAttributeName.IS_BOT]?.default === true) return true
+    if (isKnownBot(member.displayName ?? '') || isKnownBot(similarMember.keyword_displayName ?? ''))
+      return true
+
+    const primaryDn = (member.displayName ?? '').toLowerCase().trim()
+    const similarDn = (similarMember.keyword_displayName ?? '').toLowerCase().trim()
+
+    // OS-level reserved names that are never a real human identity — shared across
+    // thousands of unrelated machines and therefore meaningless as a merge signal.
+    const osReservedNames = new Set(['unknown', 'root', 'ubuntu', 'admin'])
+    if (osReservedNames.has(primaryDn) || osReservedNames.has(similarDn)) return true
+
+    // When a git/username local-part equals the displayName, the name is just the commit-time
+    // default (e.g. user.name="user", user.email="user@laptop.local").
+    for (const id of member.identities) {
+      if (
+        id.platform === PlatformType.GIT &&
+        id.type === MemberIdentityType.USERNAME &&
+        id.value.includes('@')
+      ) {
+        const lp = getEmailLocalPart(id.value)
+        if (lp === primaryDn || lp === similarDn) return true
+      }
+    }
+    for (const id of similarMember.nested_identities) {
+      if (
+        id.string_platform === PlatformType.GIT &&
+        id.keyword_type === MemberIdentityType.USERNAME &&
+        id.string_value?.includes('@')
+      ) {
+        const lp = getEmailLocalPart(id.string_value)
+        if (lp === primaryDn || lp === similarDn) return true
+      }
+    }
+
+    return false
+  }
+
+  // Checks if a noreply address on either member resolves to the other's platform username.
+  // Noreply identities can be ingested as type=email or type=username depending on the source.
   static hasMatchingUsernameFromNoreplyEmail(
     primaryMember: IMemberWithAggregatesForMergeSuggestions,
     similarMember: IMemberOpensearch,
   ): boolean {
-    // Primary member's noreply emails -> similar member's platform usernames
-    const similarUsernamesByPlatform = {
+    // Primary member's noreply identities -> similar member's platform usernames
+    const similarUsernamesByPlatform: Record<string, Set<string>> = {
       [PlatformType.GITHUB]: new Set(
         similarMember.nested_identities
           .filter(
@@ -231,35 +292,61 @@ class MemberSimilarityCalculator {
           )
           .map((i) => i.string_value?.toLowerCase()),
       ),
+      [PlatformType.GITLAB]: new Set(
+        similarMember.nested_identities
+          .filter(
+            (i) =>
+              i.string_platform === PlatformType.GITLAB &&
+              i.keyword_type === MemberIdentityType.USERNAME,
+          )
+          .map((i) => i.string_value?.toLowerCase()),
+      ),
     }
 
     for (const identity of primaryMember.identities) {
-      if (!identity.verified || identity.type !== MemberIdentityType.EMAIL) continue
+      if (!identity.verified) continue
 
       const ghUsername = parseGitHubNoreplyEmail(identity.value)
       if (ghUsername && similarUsernamesByPlatform[PlatformType.GITHUB].has(ghUsername)) {
         return true
       }
+
+      const glUsername = parseGitLabNoreplyEmail(identity.value)
+      if (glUsername && similarUsernamesByPlatform[PlatformType.GITLAB].has(glUsername)) {
+        return true
+      }
     }
 
-    // Similar member's noreply emails -> primary member's platform usernames
-    const primaryUsernamesByPlatform = {
+    // Similar member's noreply identities -> primary member's platform usernames
+    const primaryUsernamesByPlatform: Record<string, Set<string>> = {
       [PlatformType.GITHUB]: new Set(
         primaryMember.identities
           .filter(
             (i) => i.platform === PlatformType.GITHUB && i.type === MemberIdentityType.USERNAME,
           )
           .map((i) => i.value?.toLowerCase()),
       ),
+      [PlatformType.GITLAB]: new Set(
+        primaryMember.identities
+          .filter(
+            (i) => i.platform === PlatformType.GITLAB && i.type === MemberIdentityType.USERNAME,
+          )
+          .map((i) => i.value?.toLowerCase()),
+      ),
     }
 
     for (const identity of similarMember.nested_identities) {
-      if (!identity.bool_verified || identity.keyword_type !== MemberIdentityType.EMAIL) continue
+      if (!identity.bool_verified) continue
 
       const ghUsername = parseGitHubNoreplyEmail(identity.string_value)
       if (ghUsername && primaryUsernamesByPlatform[PlatformType.GITHUB].has(ghUsername)) {
         return true
       }
+
+      const glUsername = parseGitLabNoreplyEmail(identity.string_value)
+      if (glUsername && primaryUsernamesByPlatform[PlatformType.GITLAB].has(glUsername)) {
+        return true
+      }
     }
 
     return false
@@ -382,7 +469,7 @@ class MemberSimilarityCalculator {
     let isHighConfidence = false
     let confidenceScore = startingScore || this.HIGH_CONFIDENCE_SCORE
 
-    const bumpFactor = Math.floor((1 - confidenceScore) / 5)
+    const bumpFactor = (1 - confidenceScore) / 5
 
     if (this.hasSameLocation(member, similarMember)) {
       isHighConfidence = true
@@ -409,13 +496,54 @@ class MemberSimilarityCalculator {
       confidenceScore = this.bumpConfidenceScore(confidenceScore, bumpFactor)
     }
 
+    // Catches contributors whose only identity is commits from an unconfigured machine —
+    // same local-part across *.local / *.lan addresses is a strong hint they're the same person.
+    if (this.hasSameLocalPartInGitUsername(member, similarMember)) {
+      isHighConfidence = true
+      confidenceScore = this.bumpConfidenceScore(confidenceScore, bumpFactor)
+    }
+
     if (!isHighConfidence) {
       return this.LOW_CONFIDENCE_SCORE
     }
 
     return confidenceScore
   }
 
+  static hasSameLocalPartInGitUsername(
+    member: IMemberWithAggregatesForMergeSuggestions,
+    similarMember: IMemberOpensearch,
+  ): boolean {
+    const displayName = (member.displayName ?? '').toLowerCase().trim()
+    const isUsable = (lp: string) => lp.length > 0 && lp !== displayName && !isKnownBot(lp)
+
+    const primaryLocalParts = member.identities
+      .filter(
+        (i) =>
+          i.platform === PlatformType.GIT &&
+          i.type === MemberIdentityType.USERNAME &&
+          isLocalMachineEmail(i.value),
+      )
+      .map((i) => getEmailLocalPart(i.value))
+      .filter(isUsable)
+
+    if (primaryLocalParts.length === 0) return false
+
+    const similarLocalParts = new Set(
+      similarMember.nested_identities
+        .filter(
+          (i) =>
+            i.string_platform === PlatformType.GIT &&
+            i.keyword_type === MemberIdentityType.USERNAME &&
+            isLocalMachineEmail(i.string_value ?? ''),
+        )
+        .map((i) => getEmailLocalPart(i.string_value ?? ''))
+        .filter(isUsable),
+    )
+
+    return primaryLocalParts.some((lp) => similarLocalParts.has(lp))
+  }
+
   static bumpConfidenceScore(confidenceScore: number, bump: number): number {
     return Math.min(1, confidenceScore + bump)
   }

services/apps/merge_suggestions_worker/src/utils.ts

@@ -1,3 +1,4 @@
+import { isNoreplyEmail } from '@crowd/common'
 import { ILLMConsumableMember, PlatformType } from '@crowd/types'
 
 import { EMAIL_AS_USERNAME_PLATFORMS } from './enums'
@@ -21,15 +22,12 @@ export function chunkArray<T>(array: T[], chunkSize: number): T[][] {
 export const removeEmailLikeIdentitiesFromMember = (
   member: ILLMConsumableMember,
 ): ILLMConsumableMember => {
-  const nonEmailIdentities: { platform: string; value: string }[] = []
-  for (const identity of member.identities) {
-    if (identity.value.indexOf('@') === -1) {
-      // remove found identity from member.identities
-      nonEmailIdentities.push(identity)
-    }
-  }
-
-  member.identities = nonEmailIdentities
+  // Strip plain emails to avoid the LLM making false matches via shared domain suffixes.
+  // Noreply addresses are kept — their local-part is a provider-authoritative username and
+  // gives the LLM a meaningful identity signal.
+  member.identities = member.identities.filter(
+    (identity) => !identity.value.includes('@') || isNoreplyEmail(identity.value),
+  )
 
   return member
 }

services/libs/common/src/constants/email-providers.ts

@@ -1,3 +1,8 @@
+export const noreplyEmailProviders = {
+  github: '@users.noreply.github.com',
+  gitlab: '@users.noreply.gitlab.com',
+} as const
+
 export const emailProviders = new Set([
   'gmail.com',
   'gmail.co.uk',

services/libs/common/src/email.ts

@@ -1,11 +1,11 @@
 import validator from 'validator'
 
+import { noreplyEmailProviders } from './constants'
+
 export const isValidEmail = (value: string): boolean => {
   return validator.isEmail(value)
 }
 
-const GITHUB_NOREPLY_EMAIL_SUFFIX = '@users.noreply.github.com'
-
 /**
  * Extracts username from a GitHub noreply email.
  * @see https://docs.github.com/en/account-and-profile/reference/email-addresses-reference#your-noreply-email-address
@@ -14,13 +14,62 @@ export const parseGitHubNoreplyEmail = (email?: string | null): string | null =>
   if (!email) return null
 
   const lower = email.toLowerCase()
-  if (!lower.endsWith(GITHUB_NOREPLY_EMAIL_SUFFIX)) return null
+  if (!lower.endsWith(noreplyEmailProviders.github)) return null
 
-  const local = lower.slice(0, -GITHUB_NOREPLY_EMAIL_SUFFIX.length)
+  const local = lower.slice(0, -noreplyEmailProviders.github.length)
   if (!local) return null
 
   const plusIndex = local.indexOf('+')
   const username = plusIndex >= 0 ? local.slice(plusIndex + 1) : local
 
   return username || null
 }
+
+/**
+ * Extracts username from a GitLab noreply email.
+ * @see https://docs.gitlab.com/user/profile/#use-an-automatically-generated-private-commit-email
+ */
+export const parseGitLabNoreplyEmail = (email?: string | null): string | null => {
+  if (!email) return null
+
+  const lower = email.toLowerCase()
+  if (!lower.endsWith(noreplyEmailProviders.gitlab)) return null
+
+  const local = lower.slice(0, -noreplyEmailProviders.gitlab.length)
+  if (!local) return null
+
+  // Strip numeric ID prefix (e.g. "12345-username" → "username")
+  const username = /^\d+-/.test(local) ? local.slice(local.indexOf('-') + 1) : local
+  return username || null
+}
+
+/** Returns true if the value is a provider-generated noreply address. */
+export const isNoreplyEmail = (value: string): boolean => {
+  const lower = value.toLowerCase()
+  return Object.values(noreplyEmailProviders).some((s) => lower.endsWith(s))
+}
+
+/**
+ * Returns true if the email host indicates a local machine (not a real mail server).
+ * Git commits from unconfigured machines often produce addresses like user@hostname.local.
+ */
+export const isLocalMachineEmail = (value: string): boolean => {
+  const atIndex = value.indexOf('@')
+  if (atIndex < 0) return false
+  const host = value.slice(atIndex + 1).toLowerCase()
+  return (
+    host === 'localhost' ||
+    host.endsWith('.local') ||
+    host.endsWith('.lan') ||
+    host.endsWith('.localdomain')
+  )
+}
+
+/**
+ * Returns the local-part of an email (before '@'), lower-cased.
+ * Returns the full value lower-cased when there is no '@'.
+ */
+export const getEmailLocalPart = (value: string): string => {
+  const atIndex = value.indexOf('@')
+  return (atIndex >= 0 ? value.slice(0, atIndex) : value).toLowerCase()
+}