fix: reduce i18n key false positives by handling dynamic keys

Improve i18n key detection by adding path segment matching to handle dynamic keys like:
- chat:codeblock.tooltips.${windowShade ? "expand" : "collapse"}
- prompts:supportPrompts.types.${type}.label

This reduces false positives by recognizing that static keys in translation files
(like chat:codeblock.tooltips.expand) are actually used via dynamic keys in the
source code.

The solution:
- Splits keys into segments and marks dynamic parts as wildcards
- Matches static keys against these patterns
- Reduces reported unused keys from 108 to 78

Signed-off-by: Eric Wheeler <[email protected]>

Author: Eric Wheeler

locales/__tests__/find-missing-i18n-keys.test.ts

@@ -23,7 +23,7 @@ const i18nScanPatterns = [
 ]
 
 // Track line numbers for source code keys
-const lineMap = new Map<string, {file: string, line: number}>()
+const lineMap = new Map<string, { file: string; line: number }>()
 
 // Check if the key exists in all official language files, return a list of missing language files
 
@@ -53,12 +53,12 @@ function accumulateSourceKeys(): Set<string> {
 					let match
 					while ((match = pattern.exec(content)) !== null) {
 						const key = match[1]
-						const lineNumber = content.slice(0, match.index).split('\n').length
+						const lineNumber = content.slice(0, match.index).split("\n").length
 						matches.add(key)
 						sourceCodeKeys.add(key)
 						lineMap.set(key, {
 							file: path.relative(process.cwd(), filePath),
-							line: lineNumber
+							line: lineNumber,
 						})
 					}
 				}
@@ -139,24 +139,57 @@ function getKeysInSourceNotInTranslation(sourceKeys: Set<string>, translationKey
 		.sort()
 }
 
+// Function to convert a key into segments and mark dynamic parts as undefined
+function keyToSegments(key: string): (string | undefined)[] {
+	return key.split(".").map((segment) => (segment.includes("${") ? undefined : segment))
+}
+
+// Function to check if a static key matches a dynamic key pattern
+function matchesKeyPattern(staticKey: string, dynamicKey: string): boolean {
+	const staticSegments = staticKey.split(".")
+	const dynamicSegments = keyToSegments(dynamicKey)
+
+	if (staticSegments.length !== dynamicSegments.length) {
+		return false
+	}
+
+	return dynamicSegments.every((dynSeg, i) => dynSeg === undefined || dynSeg === staticSegments[i])
+}
+
 // Function 4: Return all keys in translations that are not in source
-function getKeysInTranslationNotInSource(sourceKeys: Set<string>, translationKeys: Set<string>): string[] {
+function getKeysInTranslationNotInSource(
+	sourceKeys: Set<string>,
+	translationKeys: Set<string>,
+	dynamicKeys: string[] = [],
+): string[] {
 	return Array.from(translationKeys)
-		.filter((key) => !sourceKeys.has(key))
+		.filter((key) => {
+			// If key is directly used in source, it's not unused
+			if (sourceKeys.has(key)) {
+				return false
+			}
+
+			// If key matches any dynamic key pattern, it's not unused
+			if (dynamicKeys.some((dynamicKey) => matchesKeyPattern(key, dynamicKey))) {
+				return false
+			}
+
+			return true
+		})
 		.sort()
 }
 
 // Function to find dynamic i18n keys (containing ${...})
 function findDynamicKeys(sourceKeys: Set<string>): string[] {
 	return Array.from(sourceKeys)
-		.filter(key => key.includes("${"))
+		.filter((key) => key.includes("${"))
 		.sort()
 }
 
 // Function to find non-namespaced t() calls
 export function findNonNamespacedI18nKeys(sourceKeys: Set<string>): string[] {
 	return Array.from(sourceKeys)
-		.filter(key => !key.includes(":"))
+		.filter((key) => !key.includes(":"))
 		.sort()
 }
 
@@ -187,20 +220,21 @@ export function findMissingI18nKeys(): { output: string; nonNamespacedKeys: stri
 	// Get source code keys and translation keys
 	const sourceCodeKeys = accumulateSourceKeys()
 	const translationFileKeys = accumulateTranslationKeys()
-	
+
 	// Find special keys
 	const dynamicKeys = findDynamicKeys(sourceCodeKeys)
 	const nonNamespacedKeys = findNonNamespacedI18nKeys(sourceCodeKeys)
 
 	// Create sets for set operations
 	const dynamicSet = new Set(dynamicKeys)
 	const nonNamespacedSet = new Set(nonNamespacedKeys)
-	const remainingSourceKeys = new Set(Array.from(sourceCodeKeys)
-		.filter(key => !dynamicSet.has(key) && !nonNamespacedSet.has(key)))
+	const remainingSourceKeys = new Set(
+		Array.from(sourceCodeKeys).filter((key) => !dynamicSet.has(key) && !nonNamespacedSet.has(key)),
+	)
 
 	// Find keys in source not in translations and vice versa
 	const missingTranslationKeys = getKeysInSourceNotInTranslation(remainingSourceKeys, translationFileKeys)
-	const unusedTranslationKeys = getKeysInTranslationNotInSource(remainingSourceKeys, translationFileKeys)
+	const unusedTranslationKeys = getKeysInTranslationNotInSource(remainingSourceKeys, translationFileKeys, dynamicKeys)
 
 	// Track unused keys in English locale files
 	const unusedKeys: Array<{ key: string; file: string }> = []
@@ -242,13 +276,13 @@ export function findMissingI18nKeys(): { output: string; nonNamespacedKeys: stri
 	// Add summary counts
 	summaryOutput += `\nTotal source code keys: ${sourceCodeKeys.size}\n`
 	summaryOutput += `Total translation file keys: ${translationFileKeys.size}\n`
-	
+
 	// Dynamic keys
 	summaryOutput += `\n1. Dynamic i18n keys (${dynamicKeys.length}):\n`
 	if (dynamicKeys.length === 0) {
 		summaryOutput += "  None - all i18n keys are static\n"
 	} else {
-		dynamicKeys.forEach(key => {
+		dynamicKeys.forEach((key) => {
 			const loc = lineMap.get(key)
 			summaryOutput += `  - ${loc?.file}:${loc?.line}: ${key}\n`
 		})
@@ -259,7 +293,7 @@ export function findMissingI18nKeys(): { output: string; nonNamespacedKeys: stri
 	if (nonNamespacedKeys.length === 0) {
 		summaryOutput += "  None - all t() calls use namespaces\n"
 	} else {
-		nonNamespacedKeys.forEach(key => {
+		nonNamespacedKeys.forEach((key) => {
 			const loc = lineMap.get(key)
 			summaryOutput += `  - ${loc?.file}:${loc?.line}: ${key}\n`
 		})
@@ -275,10 +309,10 @@ export function findMissingI18nKeys(): { output: string; nonNamespacedKeys: stri
 		})
 	}
 
-	// Keys in translation files but not in source code
-	summaryOutput += `\n4. Keys in translation files but not in source code (${unusedTranslationKeys.length}):\n`
+	// Keys in translation files but not in source code (excluding dynamic matches)
+	summaryOutput += `\n4. Unused translation keys (${unusedTranslationKeys.length}):\n`
 	if (unusedTranslationKeys.length === 0) {
-		summaryOutput += "  None - all translation keys are used in source code\n"
+		summaryOutput += "  None - all translation keys are either directly used or matched by dynamic patterns\n"
 	} else {
 		// Group keys by locale directory and file
 		const localeFileMap = new Map<string, Map<string, string[]>>()
@@ -348,7 +382,7 @@ export function findMissingI18nKeys(): { output: string; nonNamespacedKeys: stri
 
 	return {
 		output: printLogs(),
-		nonNamespacedKeys
+		nonNamespacedKeys,
 	}
 }
 
@@ -371,12 +405,17 @@ describe("Find Missing i18n Keys", () => {
 		// Create sets for set operations
 		const dynamicSet = new Set(dynamicKeys)
 		const nonNamespacedSet = new Set(nonNamespacedKeys)
-		const remainingSourceKeys = new Set(Array.from(sourceKeys)
-			.filter(key => !dynamicSet.has(key) && !nonNamespacedSet.has(key)))
+		const remainingSourceKeys = new Set(
+			Array.from(sourceKeys).filter((key) => !dynamicSet.has(key) && !nonNamespacedSet.has(key)),
+		)
 
 		// Find differences
 		keysInSourceNotInTranslation = getKeysInSourceNotInTranslation(remainingSourceKeys, translationKeys)
-		keysInTranslationNotInSource = getKeysInTranslationNotInSource(remainingSourceKeys, translationKeys)
+		keysInTranslationNotInSource = getKeysInTranslationNotInSource(
+			remainingSourceKeys,
+			translationKeys,
+			dynamicKeys,
+		)
 
 		// Clear logs at start
 		clearLogs()