@n8n/eslint-plugin-community-nodes 0.4.0 → 0.6.0

package/src/rules/no-deprecated-workflow-functions.ts

@@ -1,4 +1,7 @@
-import { ESLintUtils, TSESTree } from '@typescript-eslint/utils';
+import type { TSESTree } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+import { createRule } from '../utils/index.js';
 
 const DEPRECATED_FUNCTIONS = {
 	request: 'httpRequest',
@@ -21,7 +24,8 @@ function isDeprecatedTypeName(name: string): name is keyof typeof DEPRECATED_TYP
 	return name in DEPRECATED_TYPES;
 }
 
-export const NoDeprecatedWorkflowFunctionsRule = ESLintUtils.RuleCreator.withoutDocs({
+export const NoDeprecatedWorkflowFunctionsRule = createRule({
+	name: 'no-deprecated-workflow-functions',
 	meta: {
 		type: 'problem',
 		docs: {
@@ -34,8 +38,11 @@ export const NoDeprecatedWorkflowFunctionsRule = ESLintUtils.RuleCreator.without
 			deprecatedType: "'{{ typeName }}' is deprecated. Use '{{ replacement }}' instead.",
 			deprecatedWithoutReplacement:
 				"'{{ functionName }}' is deprecated and should be removed or replaced with alternative implementation.",
+			suggestReplaceFunction: "Replace '{{ functionName }}' with '{{ replacement }}'",
+			suggestReplaceType: "Replace '{{ typeName }}' with '{{ replacement }}'",
 		},
 		schema: [],
+		hasSuggestions: true,
 	},
 	defaultOptions: [],
 	create(context) {
@@ -45,7 +52,10 @@ export const NoDeprecatedWorkflowFunctionsRule = ESLintUtils.RuleCreator.without
 			ImportDeclaration(node) {
 				if (node.source.value === 'n8n-workflow') {
 					node.specifiers.forEach((specifier) => {
-						if (specifier.type === 'ImportSpecifier' && specifier.imported.type === 'Identifier') {
+						if (
+							specifier.type === AST_NODE_TYPES.ImportSpecifier &&
+							specifier.imported.type === AST_NODE_TYPES.Identifier
+						) {
 							n8nWorkflowTypes.add(specifier.local.name);
 						}
 					});
@@ -53,7 +63,10 @@ export const NoDeprecatedWorkflowFunctionsRule = ESLintUtils.RuleCreator.without
 			},
 
 			MemberExpression(node) {
-				if (node.property.type === 'Identifier' && isDeprecatedFunctionName(node.property.name)) {
+				if (
+					node.property.type === AST_NODE_TYPES.Identifier &&
+					isDeprecatedFunctionName(node.property.name)
+				) {
 					if (!isThisHelpersAccess(node)) {
 						return;
 					}
@@ -74,6 +87,13 @@ export const NoDeprecatedWorkflowFunctionsRule = ESLintUtils.RuleCreator.without
 								replacement,
 								message: getDeprecationMessage(functionName),
 							},
+							suggest: [
+								{
+									messageId: 'suggestReplaceFunction',
+									data: { functionName, replacement },
+									fix: (fixer) => fixer.replaceText(node.property, replacement),
+								},
+							],
 						});
 					} else {
 						context.report({
@@ -89,7 +109,7 @@ export const NoDeprecatedWorkflowFunctionsRule = ESLintUtils.RuleCreator.without
 
 			TSTypeReference(node) {
 				if (
-					node.typeName.type === 'Identifier' &&
+					node.typeName.type === AST_NODE_TYPES.Identifier &&
 					isDeprecatedTypeName(node.typeName.name) &&
 					n8nWorkflowTypes.has(node.typeName.name)
 				) {
@@ -103,6 +123,13 @@ export const NoDeprecatedWorkflowFunctionsRule = ESLintUtils.RuleCreator.without
 							typeName,
 							replacement,
 						},
+						suggest: [
+							{
+								messageId: 'suggestReplaceType',
+								data: { typeName, replacement },
+								fix: (fixer) => fixer.replaceText(node.typeName, replacement),
+							},
+						],
 					});
 				}
 			},
@@ -111,9 +138,9 @@ export const NoDeprecatedWorkflowFunctionsRule = ESLintUtils.RuleCreator.without
 				// Check if this import is from n8n-workflow by looking at the parent ImportDeclaration
 				const importDeclaration = node.parent;
 				if (
-					importDeclaration?.type === 'ImportDeclaration' &&
+					importDeclaration?.type === AST_NODE_TYPES.ImportDeclaration &&
 					importDeclaration.source.value === 'n8n-workflow' &&
-					node.imported.type === 'Identifier' &&
+					node.imported.type === AST_NODE_TYPES.Identifier &&
 					isDeprecatedTypeName(node.imported.name)
 				) {
 					const typeName = node.imported.name;
@@ -126,6 +153,13 @@ export const NoDeprecatedWorkflowFunctionsRule = ESLintUtils.RuleCreator.without
 							typeName,
 							replacement,
 						},
+						suggest: [
+							{
+								messageId: 'suggestReplaceType',
+								data: { typeName, replacement },
+								fix: (fixer) => fixer.replaceText(node.imported, replacement),
+							},
+						],
 					});
 				}
 			},
@@ -137,11 +171,11 @@ export const NoDeprecatedWorkflowFunctionsRule = ESLintUtils.RuleCreator.without
  * Check if the MemberExpression follows the this.helpers.* pattern
  */
 function isThisHelpersAccess(node: TSESTree.MemberExpression): boolean {
-	if (node.object?.type === 'MemberExpression') {
+	if (node.object?.type === AST_NODE_TYPES.MemberExpression) {
 		const outerObject = node.object;
 		return (
-			outerObject.object?.type === 'ThisExpression' &&
-			outerObject.property?.type === 'Identifier' &&
+			outerObject.object?.type === AST_NODE_TYPES.ThisExpression &&
+			outerObject.property?.type === AST_NODE_TYPES.Identifier &&
 			outerObject.property.name === 'helpers'
 		);
 	}

package/src/rules/no-restricted-globals.test.ts

@@ -1,4 +1,5 @@
 import { RuleTester } from '@typescript-eslint/rule-tester';
+
 import { NoRestrictedGlobalsRule } from './no-restricted-globals.js';
 
 const ruleTester = new RuleTester();

package/src/rules/no-restricted-globals.ts

@@ -1,6 +1,8 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
+import { TSESTree } from '@typescript-eslint/types';
 import type { TSESLint } from '@typescript-eslint/utils';
 
+import { createRule } from '../utils/index.js';
+
 const restrictedGlobals = [
 	'clearInterval',
 	'clearTimeout',
@@ -15,7 +17,8 @@ const restrictedGlobals = [
 	'__filename',
 ];
 
-export const NoRestrictedGlobalsRule = ESLintUtils.RuleCreator.withoutDocs({
+export const NoRestrictedGlobalsRule = createRule({
+	name: 'no-restricted-globals',
 	meta: {
 		type: 'problem',
 		docs: {
@@ -33,7 +36,7 @@ export const NoRestrictedGlobalsRule = ESLintUtils.RuleCreator.withoutDocs({
 
 			// Skip property access (like console.process - we want process.exit but not obj.process)
 			if (
-				parent?.type === 'MemberExpression' &&
+				parent?.type === TSESTree.AST_NODE_TYPES.MemberExpression &&
 				parent.property === ref.identifier &&
 				!parent.computed
 			) {

package/src/rules/no-restricted-imports.test.ts

@@ -1,4 +1,5 @@
 import { RuleTester } from '@typescript-eslint/rule-tester';
+
 import { NoRestrictedImportsRule } from './no-restricted-imports.js';
 
 const ruleTester = new RuleTester();

package/src/rules/no-restricted-imports.ts

@@ -1,5 +1,9 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-import { getModulePath, isDirectRequireCall, isRequireMemberCall } from '../utils/index.js';
+import {
+	getModulePath,
+	isDirectRequireCall,
+	isRequireMemberCall,
+	createRule,
+} from '../utils/index.js';
 
 const allowedModules = [
 	'n8n-workflow',
@@ -22,7 +26,8 @@ const isModuleAllowed = (modulePath: string): boolean => {
 	return allowedModules.includes(moduleName);
 };
 
-export const NoRestrictedImportsRule = ESLintUtils.RuleCreator.withoutDocs({
+export const NoRestrictedImportsRule = createRule({
+	name: 'no-restricted-imports',
 	meta: {
 		type: 'problem',
 		docs: {

package/src/rules/node-usable-as-tool.test.ts

@@ -1,4 +1,5 @@
 import { RuleTester } from '@typescript-eslint/rule-tester';
+
 import { NodeUsableAsToolRule } from './node-usable-as-tool.js';
 
 const ruleTester = new RuleTester();

package/src/rules/node-usable-as-tool.ts

@@ -1,12 +1,14 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
+import { TSESTree } from '@typescript-eslint/types';
+
 import {
 	isNodeTypeClass,
 	findClassProperty,
 	findObjectProperty,
-	getBooleanLiteralValue,
+	createRule,
 } from '../utils/index.js';
 
-export const NodeUsableAsToolRule = ESLintUtils.RuleCreator.withoutDocs({
+export const NodeUsableAsToolRule = createRule({
+	name: 'node-usable-as-tool',
 	meta: {
 		type: 'problem',
 		docs: {
@@ -33,7 +35,7 @@ export const NodeUsableAsToolRule = ESLintUtils.RuleCreator.withoutDocs({
 				}
 
 				const descriptionValue = descriptionProperty.value;
-				if (descriptionValue?.type !== 'ObjectExpression') {
+				if (descriptionValue?.type !== TSESTree.AST_NODE_TYPES.ObjectExpression) {
 					return;
 				}
 
@@ -44,10 +46,10 @@ export const NodeUsableAsToolRule = ESLintUtils.RuleCreator.withoutDocs({
 						node,
 						messageId: 'missingUsableAsTool',
 						fix(fixer) {
-							if (descriptionValue?.type === 'ObjectExpression') {
+							if (descriptionValue?.type === TSESTree.AST_NODE_TYPES.ObjectExpression) {
 								const properties = descriptionValue.properties;
 								if (properties.length === 0) {
-									const openBrace = descriptionValue.range![0] + 1;
+									const openBrace = descriptionValue.range[0] + 1;
 									return fixer.insertTextAfterRange(
 										[openBrace, openBrace],
 										'\n\t\tusableAsTool: true,',

package/src/rules/package-name-convention.test.ts

@@ -1,4 +1,5 @@
 import { RuleTester } from '@typescript-eslint/rule-tester';
+
 import { PackageNameConventionRule } from './package-name-convention.js';
 
 const ruleTester = new RuleTester();
@@ -80,33 +81,109 @@ ruleTester.run('package-name-convention', PackageNameConventionRule, {
 			name: 'invalid package name - generic',
 			filename: 'package.json',
 			code: '{ "name": "my-package", "version": "1.0.0" }',
-			errors: [{ messageId: 'invalidPackageName', data: { packageName: 'my-package' } }],
+			errors: [
+				{
+					messageId: 'invalidPackageName',
+					data: { packageName: 'my-package' },
+					suggestions: [
+						{
+							messageId: 'renameTo',
+							data: { suggestedName: 'n8n-nodes-my-package' },
+							output: '{ "name": "n8n-nodes-my-package", "version": "1.0.0" }',
+						},
+					],
+				},
+			],
 		},
 		{
 			name: 'invalid package name - missing nodes',
 			filename: 'package.json',
 			code: '{ "name": "n8n-example", "version": "1.0.0" }',
-			errors: [{ messageId: 'invalidPackageName', data: { packageName: 'n8n-example' } }],
+			errors: [
+				{
+					messageId: 'invalidPackageName',
+					data: { packageName: 'n8n-example' },
+					suggestions: [
+						{
+							messageId: 'renameTo',
+							data: { suggestedName: 'n8n-nodes-example' },
+							output: '{ "name": "n8n-nodes-example", "version": "1.0.0" }',
+						},
+					],
+				},
+			],
 		},
 		{
 			name: 'invalid scoped package name',
 			filename: 'package.json',
 			code: '{ "name": "@company/example-nodes", "version": "1.0.0" }',
 			errors: [
-				{ messageId: 'invalidPackageName', data: { packageName: '@company/example-nodes' } },
+				{
+					messageId: 'invalidPackageName',
+					data: { packageName: '@company/example-nodes' },
+					suggestions: [
+						{
+							messageId: 'renameTo',
+							data: { suggestedName: '@company/n8n-nodes-example' },
+							output: '{ "name": "@company/n8n-nodes-example", "version": "1.0.0" }',
+						},
+					],
+				},
 			],
 		},
 		{
 			name: 'invalid package name - wrong order',
 			filename: 'package.json',
 			code: '{ "name": "nodes-n8n-example", "version": "1.0.0" }',
-			errors: [{ messageId: 'invalidPackageName', data: { packageName: 'nodes-n8n-example' } }],
+			errors: [
+				{
+					messageId: 'invalidPackageName',
+					data: { packageName: 'nodes-n8n-example' },
+					suggestions: [
+						{
+							messageId: 'renameTo',
+							data: { suggestedName: 'n8n-nodes-example' },
+							output: '{ "name": "n8n-nodes-example", "version": "1.0.0" }',
+						},
+					],
+				},
+			],
 		},
 		{
 			name: 'empty package name',
 			filename: 'package.json',
 			code: '{ "name": "", "version": "1.0.0" }',
-			errors: [{ messageId: 'invalidPackageName', data: { packageName: '' } }],
+			errors: [
+				{
+					messageId: 'invalidPackageName',
+					data: { packageName: '' },
+					suggestions: [],
+				},
+			],
+		},
+		{
+			name: 'incomplete package name with missing suffix',
+			filename: 'package.json',
+			code: '{ "name": "n8n-nodes-", "version": "1.0.0" }',
+			errors: [
+				{
+					messageId: 'invalidPackageName',
+					data: { packageName: 'n8n-nodes-' },
+					suggestions: [],
+				},
+			],
+		},
+		{
+			name: 'incomplete scoped package name with missing suffix',
+			filename: 'package.json',
+			code: '{ "name": "@company/n8n-nodes-", "version": "1.0.0" }',
+			errors: [
+				{
+					messageId: 'invalidPackageName',
+					data: { packageName: '@company/n8n-nodes-' },
+					suggestions: [],
+				},
+			],
 		},
 	],
 });

package/src/rules/package-name-convention.ts

@@ -1,16 +1,23 @@
-import { ESLintUtils, TSESTree, AST_NODE_TYPES } from '@typescript-eslint/utils';
+import type { TSESTree } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import type { ReportSuggestionArray } from '@typescript-eslint/utils/ts-eslint';
 
-export const PackageNameConventionRule = ESLintUtils.RuleCreator.withoutDocs({
+import { createRule } from '../utils/index.js';
+
+export const PackageNameConventionRule = createRule({
+	name: 'package-name-convention',
 	meta: {
 		type: 'problem',
 		docs: {
 			description: 'Enforce correct package naming convention for n8n community nodes',
 		},
 		messages: {
+			renameTo: "Rename to '{{suggestedName}}'",
 			invalidPackageName:
 				'Package name "{{ packageName }}" must follow the convention "n8n-nodes-[PACKAGE-NAME]" or "@[AUTHOR]/n8n-nodes-[PACKAGE-NAME]"',
 		},
 		schema: [],
+		hasSuggestions: true,
 	},
 	defaultOptions: [],
 	create(context) {
@@ -43,12 +50,29 @@ export const PackageNameConventionRule = ESLintUtils.RuleCreator.withoutDocs({
 				const packageNameStr = typeof packageName === 'string' ? packageName : null;
 
 				if (!packageNameStr || !isValidPackageName(packageNameStr)) {
+					const suggestions: ReportSuggestionArray<'invalidPackageName' | 'renameTo'> = [];
+
+					// Generate package name suggestions if we have a valid string
+					if (packageNameStr) {
+						const suggestedNames = generatePackageNameSuggestions(packageNameStr);
+						for (const suggestedName of suggestedNames) {
+							suggestions.push({
+								messageId: 'renameTo',
+								data: { suggestedName },
+								fix(fixer) {
+									return fixer.replaceText(nameProperty.value, `"${suggestedName}"`);
+								},
+							});
+						}
+					}
+
 					context.report({
 						node: nameProperty,
 						messageId: 'invalidPackageName',
 						data: {
 							packageName: packageNameStr ?? 'undefined',
 						},
+						suggest: suggestions,
 					});
 				}
 			},
@@ -61,3 +85,23 @@ function isValidPackageName(name: string): boolean {
 	const scoped = /^@.+\/n8n-nodes-.+$/;
 	return unscoped.test(name) || scoped.test(name);
 }
+
+function generatePackageNameSuggestions(invalidName: string): string[] {
+	const cleanName = (name: string) => {
+		return name
+			.replace(/^nodes?-?n8n-?/, '')
+			.replace(/^n8n-/, '')
+			.replace(/^nodes?-?/, '')
+			.replace(/^node-/, '')
+			.replace(/-nodes$/, '');
+	};
+
+	if (invalidName.startsWith('@')) {
+		const [scope, packagePart] = invalidName.split('/');
+		const clean = cleanName(packagePart ?? '');
+		return clean ? [`${scope}/n8n-nodes-${clean}`] : [];
+	}
+
+	const clean = cleanName(invalidName);
+	return clean ? [`n8n-nodes-${clean}`] : [];
+}

package/src/rules/resource-operation-pattern.test.ts

@@ -1,4 +1,5 @@
 import { RuleTester } from '@typescript-eslint/rule-tester';
+
 import { ResourceOperationPatternRule } from './resource-operation-pattern.js';
 
 const ruleTester = new RuleTester();

package/src/rules/resource-operation-pattern.ts

@@ -1,13 +1,17 @@
-import { ESLintUtils, TSESTree } from '@typescript-eslint/utils';
+import type { TSESTree } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
 import {
 	isNodeTypeClass,
 	findClassProperty,
 	findObjectProperty,
 	getStringLiteralValue,
 	isFileType,
+	createRule,
 } from '../utils/index.js';
 
-export const ResourceOperationPatternRule = ESLintUtils.RuleCreator.withoutDocs({
+export const ResourceOperationPatternRule = createRule({
+	name: 'resource-operation-pattern',
 	meta: {
 		type: 'problem',
 		docs: {
@@ -26,12 +30,15 @@ export const ResourceOperationPatternRule = ESLintUtils.RuleCreator.withoutDocs(
 		}
 
 		const analyzeNodeDescription = (descriptionValue: TSESTree.Expression | null): void => {
-			if (!descriptionValue || descriptionValue.type !== 'ObjectExpression') {
+			if (!descriptionValue || descriptionValue.type !== AST_NODE_TYPES.ObjectExpression) {
 				return;
 			}
 
 			const propertiesProperty = findObjectProperty(descriptionValue, 'properties');
-			if (!propertiesProperty?.value || propertiesProperty.value.type !== 'ArrayExpression') {
+			if (
+				!propertiesProperty?.value ||
+				propertiesProperty.value.type !== AST_NODE_TYPES.ArrayExpression
+			) {
 				return;
 			}
 
@@ -41,7 +48,7 @@ export const ResourceOperationPatternRule = ESLintUtils.RuleCreator.withoutDocs(
 			let operationNode: TSESTree.Node | null = null;
 
 			for (const property of propertiesArray.elements) {
-				if (!property || property.type !== 'ObjectExpression') {
+				if (!property || property.type !== AST_NODE_TYPES.ObjectExpression) {
 					continue;
 				}
 
@@ -62,7 +69,7 @@ export const ResourceOperationPatternRule = ESLintUtils.RuleCreator.withoutDocs(
 				if (name === 'operation' && type === 'options') {
 					operationNode = property;
 					const optionsProperty = findObjectProperty(property, 'options');
-					if (optionsProperty?.value?.type === 'ArrayExpression') {
+					if (optionsProperty?.value?.type === AST_NODE_TYPES.ArrayExpression) {
 						operationCount = optionsProperty.value.elements.length;
 					}
 				}

package/src/utils/ast-utils.ts

@@ -1,11 +1,13 @@
-import { TSESTree, AST_NODE_TYPES } from '@typescript-eslint/utils';
+import type { TSESTree } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { distance } from 'fastest-levenshtein';
 
 function implementsInterface(node: TSESTree.ClassDeclaration, interfaceName: string): boolean {
 	return (
 		node.implements?.some(
 			(impl) =>
-				impl.type === 'TSClassImplements' &&
-				impl.expression.type === 'Identifier' &&
+				impl.type === AST_NODE_TYPES.TSClassImplements &&
+				impl.expression.type === AST_NODE_TYPES.Identifier &&
 				impl.expression.name === interfaceName,
 		) ?? false
 	);
@@ -16,7 +18,7 @@ export function isNodeTypeClass(node: TSESTree.ClassDeclaration): boolean {
 		return true;
 	}
 
-	if (node.superClass?.type === 'Identifier' && node.superClass.name === 'Node') {
+	if (node.superClass?.type === AST_NODE_TYPES.Identifier && node.superClass.name === 'Node') {
 		return true;
 	}
 
@@ -33,11 +35,11 @@ export function findClassProperty(
 ): TSESTree.PropertyDefinition | null {
 	const property = node.body.body.find(
 		(member) =>
-			member.type === 'PropertyDefinition' &&
-			member.key?.type === 'Identifier' &&
+			member.type === AST_NODE_TYPES.PropertyDefinition &&
+			member.key?.type === AST_NODE_TYPES.Identifier &&
 			member.key.name === propertyName,
 	);
-	return property?.type === 'PropertyDefinition' ? property : null;
+	return property?.type === AST_NODE_TYPES.PropertyDefinition ? property : null;
 }
 
 export function findObjectProperty(
@@ -46,13 +48,15 @@ export function findObjectProperty(
 ): TSESTree.Property | null {
 	const property = obj.properties.find(
 		(prop) =>
-			prop.type === 'Property' && prop.key.type === 'Identifier' && prop.key.name === propertyName,
+			prop.type === AST_NODE_TYPES.Property &&
+			prop.key.type === AST_NODE_TYPES.Identifier &&
+			prop.key.name === propertyName,
 	);
-	return property?.type === 'Property' ? property : null;
+	return property?.type === AST_NODE_TYPES.Property ? property : null;
 }
 
 export function getLiteralValue(node: TSESTree.Node | null): string | boolean | number | null {
-	if (node?.type === 'Literal') {
+	if (node?.type === AST_NODE_TYPES.Literal) {
 		return node.value as string | boolean | number | null;
 	}
 	return null;
@@ -70,7 +74,7 @@ export function getModulePath(node: TSESTree.Node | null): string | null {
 	}
 
 	if (
-		node?.type === 'TemplateLiteral' &&
+		node?.type === AST_NODE_TYPES.TemplateLiteral &&
 		node.expressions.length === 0 &&
 		node.quasis.length === 1
 	) {
@@ -90,7 +94,7 @@ export function findArrayLiteralProperty(
 	propertyName: string,
 ): TSESTree.ArrayExpression | null {
 	const property = findObjectProperty(obj, propertyName);
-	if (property?.value.type === 'ArrayExpression') {
+	if (property?.value.type === AST_NODE_TYPES.ArrayExpression) {
 		return property.value;
 	}
 	return null;
@@ -100,11 +104,11 @@ export function hasArrayLiteralValue(
 	node: TSESTree.PropertyDefinition,
 	searchValue: string,
 ): boolean {
-	if (node.value?.type !== 'ArrayExpression') return false;
+	if (node.value?.type !== AST_NODE_TYPES.ArrayExpression) return false;
 
 	return node.value.elements.some(
 		(element) =>
-			element?.type === 'Literal' &&
+			element?.type === AST_NODE_TYPES.Literal &&
 			typeof element.value === 'string' &&
 			element.value === searchValue,
 	);
@@ -125,14 +129,16 @@ export function isFileType(filename: string, extension: string): boolean {
 
 export function isDirectRequireCall(node: TSESTree.CallExpression): boolean {
 	return (
-		node.callee.type === 'Identifier' && node.callee.name === 'require' && node.arguments.length > 0
+		node.callee.type === AST_NODE_TYPES.Identifier &&
+		node.callee.name === 'require' &&
+		node.arguments.length > 0
 	);
 }
 
 export function isRequireMemberCall(node: TSESTree.CallExpression): boolean {
 	return (
-		node.callee.type === 'MemberExpression' &&
-		node.callee.object.type === 'Identifier' &&
+		node.callee.type === AST_NODE_TYPES.MemberExpression &&
+		node.callee.object.type === AST_NODE_TYPES.Identifier &&
 		node.callee.object.name === 'require' &&
 		node.arguments.length > 0
 	);
@@ -148,7 +154,7 @@ export function extractCredentialInfoFromArray(
 		return { name: stringValue, node: element };
 	}
 
-	if (element.type === 'ObjectExpression') {
+	if (element.type === AST_NODE_TYPES.ObjectExpression) {
 		const nameProperty = findObjectProperty(element, 'name');
 		const testedByProperty = findObjectProperty(element, 'testedBy');
 
@@ -161,7 +167,7 @@ export function extractCredentialInfoFromArray(
 			if (nameValue) {
 				return {
 					name: nameValue,
-					testedBy: testedByValue || undefined,
+					testedBy: testedByValue ?? undefined,
 					node: nameProperty.value,
 				};
 			}
@@ -177,3 +183,25 @@ export function extractCredentialNameFromArray(
 	const info = extractCredentialInfoFromArray(element);
 	return info ? { name: info.name, node: info.node } : null;
 }
+
+export function findSimilarStrings(
+	target: string,
+	candidates: Set<string>,
+	maxDistance: number = 3,
+	maxResults: number = 3,
+): string[] {
+	const matches: Array<{ name: string; distance: number }> = [];
+
+	for (const candidate of candidates) {
+		const levenshteinDistance = distance(target.toLowerCase(), candidate.toLowerCase());
+
+		if (levenshteinDistance <= maxDistance) {
+			matches.push({ name: candidate, distance: levenshteinDistance });
+		}
+	}
+
+	return matches
+		.sort((a, b) => a.distance - b.distance)
+		.slice(0, maxResults)
+		.map((match) => match.name);
+}