archforge-x 1.0.7 → 2.0.0-beta.1

package/dist/analyzers/dependency.js

@@ -9,6 +9,11 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const typescript_1 = __importDefault(require("typescript"));
 const chalk_1 = __importDefault(require("chalk"));
+const minimatch_1 = require("minimatch");
+// Ignore comment patterns
+const IGNORE_FILE_PATTERN = /@archforge-ignore-file/;
+const IGNORE_LINE_PATTERN = /@archforge-ignore-line/;
+const IGNORE_NEXT_LINE_PATTERN = /@archforge-ignore-next-line/;
 // --- LANGUAGE PARSERS ---
 const parseImportsTS = (content, filePath) => {
     const imports = [];
@@ -16,21 +21,74 @@ const parseImportsTS = (content, filePath) => {
     sourceFile.forEachChild((node) => {
         if (typescript_1.default.isImportDeclaration(node) && node.moduleSpecifier) {
             const importPath = node.moduleSpecifier.text;
-            imports.push(importPath);
+            const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+            imports.push({
+                path: importPath,
+                line: line + 1, // Convert to 1-based
+                column: character + 1
+            });
         }
         if (typescript_1.default.isVariableStatement(node)) {
             const text = node.getText();
             const match = text.match(/require\(['"](.+)['"]\)/);
-            if (match)
-                imports.push(match[1]);
+            if (match) {
+                const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+                imports.push({
+                    path: match[1],
+                    line: line + 1,
+                    column: character + 1
+                });
+            }
         }
     });
     return imports;
 };
+/**
+ * Check if a file should be completely ignored
+ */
+function shouldIgnoreFile(content, filePath, arch) {
+    // Check for @archforge-ignore-file comment
+    if (IGNORE_FILE_PATTERN.test(content)) {
+        const match = content.match(/@archforge-ignore-file(?:\s*:\s*(.+))?/);
+        return { ignored: true, reason: match?.[1]?.trim() || 'File-level ignore' };
+    }
+    // Check against config ignore patterns
+    if (arch.ignore?.files?.includes(filePath)) {
+        return { ignored: true, reason: 'Listed in ignore.files' };
+    }
+    if (arch.ignore?.patterns) {
+        for (const pattern of arch.ignore.patterns) {
+            if ((0, minimatch_1.minimatch)(filePath, pattern)) {
+                return { ignored: true, reason: `Matches ignore pattern: ${pattern}` };
+            }
+        }
+    }
+    return { ignored: false };
+}
+/**
+ * Check if a specific line should be ignored
+ */
+function shouldIgnoreLine(lines, lineNumber) {
+    const lineIndex = lineNumber - 1;
+    const currentLine = lines[lineIndex] || '';
+    const previousLine = lines[lineIndex - 1] || '';
+    // Check current line for inline ignore
+    if (IGNORE_LINE_PATTERN.test(currentLine)) {
+        const match = currentLine.match(/@archforge-ignore-line(?:\s*:\s*(.+))?/);
+        return { ignored: true, reason: match?.[1]?.trim() || 'Inline ignore' };
+    }
+    // Check previous line for next-line ignore
+    if (IGNORE_NEXT_LINE_PATTERN.test(previousLine)) {
+        const match = previousLine.match(/@archforge-ignore-next-line(?:\s*:\s*(.+))?/);
+        return { ignored: true, reason: match?.[1]?.trim() || 'Next-line ignore' };
+    }
+    return { ignored: false };
+}
 // --- CORE ANALYZER ---
 function analyzeDependencies(arch, options = {}) {
     const violations = [];
     const projectRoot = path_1.default.resolve(arch.project.root || ".");
+    const forbiddenPackages = arch.rules?.imports?.forbiddenPackages || [];
     function getLayerByPath(filePath) {
         const absoluteFile = path_1.default.resolve(filePath);
         const sortedLayers = [...arch.layers].sort((a, b) => b.path.length - a.path.length);
@@ -85,37 +143,145 @@ function analyzeDependencies(arch, options = {}) {
         if (!currentLayer)
             return;
         const content = fs_extra_1.default.readFileSync(filePath, "utf-8");
+        const relativeFilePath = path_1.default.relative(projectRoot, filePath);
+        const lines = content.split('\n');
+        // Check if entire file should be ignored
+        const fileIgnore = shouldIgnoreFile(content, relativeFilePath, arch);
+        if (fileIgnore.ignored && !options.includeIgnored) {
+            return;
+        }
         let imports = [];
-        if ([".ts", ".tsx", ".js", ".jsx"].includes(ext))
+        if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
             imports = parseImportsTS(content, filePath);
-        for (const importStr of imports) {
-            const importedLayer = resolveImportedLayer(filePath, importStr);
+        }
+        for (const importInfo of imports) {
+            // Check for line-level ignore
+            const lineIgnore = shouldIgnoreLine(lines, importInfo.line);
+            const isIgnored = fileIgnore.ignored || lineIgnore.ignored;
+            const ignoreReason = fileIgnore.reason || lineIgnore.reason;
+            // Check forbidden packages first
+            const packageName = importInfo.path.split('/')[0];
+            const forbiddenPkg = forbiddenPackages.find(fp => fp.name === packageName || importInfo.path.startsWith(fp.name));
+            if (forbiddenPkg) {
+                const violation = {
+                    file: relativeFilePath,
+                    line: importInfo.line,
+                    column: importInfo.column,
+                    fromLayer: currentLayer.name,
+                    importedLayer: packageName,
+                    importPath: importInfo.path,
+                    type: "forbidden-package",
+                    severity: forbiddenPkg.severity || "error",
+                    message: forbiddenPkg.message || `Package '${packageName}' is forbidden`,
+                    ignored: isIgnored,
+                    ignoreReason
+                };
+                if (!isIgnored || options.includeIgnored) {
+                    violations.push(violation);
+                }
+                continue;
+            }
+            // Check layer violations
+            const importedLayer = resolveImportedLayer(filePath, importInfo.path);
             if (!importedLayer || importedLayer.name === currentLayer.name)
                 continue;
             const canImport = currentLayer.canImport || currentLayer.allowedImports || [];
             if (!canImport.includes(importedLayer.name)) {
-                violations.push({
-                    file: path_1.default.relative(projectRoot, filePath),
+                const violation = {
+                    file: relativeFilePath,
+                    line: importInfo.line,
+                    column: importInfo.column,
                     fromLayer: currentLayer.name,
                     importedLayer: importedLayer.name,
-                    importPath: importStr,
+                    importPath: importInfo.path,
                     type: "forbidden",
-                    severity: "error"
-                });
+                    severity: "error",
+                    ignored: isIgnored,
+                    ignoreReason
+                };
+                if (!isIgnored || options.includeIgnored) {
+                    violations.push(violation);
+                }
             }
         }
     }
+    // Check file location rules
+    function checkFileLocations() {
+        const locationRules = arch.rules?.fileLocations || [];
+        if (locationRules.length === 0)
+            return;
+        function scanForLocationViolations(folderPath) {
+            const absoluteFolderPath = path_1.default.resolve(projectRoot, folderPath);
+            if (!fs_extra_1.default.existsSync(absoluteFolderPath))
+                return;
+            const entries = fs_extra_1.default.readdirSync(absoluteFolderPath);
+            for (const entry of entries) {
+                const fullPath = path_1.default.join(absoluteFolderPath, entry);
+                const stat = fs_extra_1.default.statSync(fullPath);
+                if (stat.isDirectory()) {
+                    if (["node_modules", ".git", "dist"].includes(entry))
+                        continue;
+                    scanForLocationViolations(fullPath);
+                }
+                else if (stat.isFile()) {
+                    const relativeFilePath = path_1.default.relative(projectRoot, fullPath);
+                    for (const rule of locationRules) {
+                        if ((0, minimatch_1.minimatch)(entry, rule.pattern) || (0, minimatch_1.minimatch)(relativeFilePath, rule.pattern)) {
+                            const isInAllowedPath = rule.allowedPaths.some(allowedPath => (0, minimatch_1.minimatch)(relativeFilePath, allowedPath));
+                            if (!isInAllowedPath) {
+                                const content = fs_extra_1.default.readFileSync(fullPath, "utf-8");
+                                const fileIgnore = shouldIgnoreFile(content, relativeFilePath, arch);
+                                if (!fileIgnore.ignored || options.includeIgnored) {
+                                    violations.push({
+                                        file: relativeFilePath,
+                                        fromLayer: "unknown",
+                                        importedLayer: "N/A",
+                                        importPath: "N/A",
+                                        type: "file-location",
+                                        severity: rule.severity,
+                                        message: rule.message || `File '${entry}' is not in an allowed location. Expected: ${rule.allowedPaths.join(' or ')}`,
+                                        ignored: fileIgnore.ignored,
+                                        ignoreReason: fileIgnore.reason
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        scanForLocationViolations("src");
+    }
     arch.layers.forEach((layer) => scanFolder(layer.path));
-    return violations;
+    checkFileLocations();
+    // Sort violations: errors first, then by file
+    return violations.sort((a, b) => {
+        if (a.ignored !== b.ignored)
+            return a.ignored ? 1 : -1;
+        if (a.severity !== b.severity) {
+            const severityOrder = { error: 0, warning: 1, info: 2 };
+            return severityOrder[a.severity] - severityOrder[b.severity];
+        }
+        return a.file.localeCompare(b.file);
+    });
 }
 function reportViolations(violations, options = {}) {
-    if (violations.length === 0) {
+    const activeViolations = violations.filter(v => !v.ignored);
+    const ignoredViolations = violations.filter(v => v.ignored);
+    if (activeViolations.length === 0) {
         console.log(chalk_1.default.green("✅ No architectural violations found. Architecture is clean."));
+        if (ignoredViolations.length > 0) {
+            console.log(chalk_1.default.gray(`   (${ignoredViolations.length} violation(s) ignored via @archforge-ignore)`));
+        }
         return;
     }
-    console.log(chalk_1.default.red.bold(`❌ Found ${violations.length} Architecture Violations:`));
-    const grouped = violations.reduce((acc, v) => {
-        const key = `${v.fromLayer} -> ${v.importedLayer}`;
+    console.log(chalk_1.default.red.bold(`\n❌ Found ${activeViolations.length} Architecture Violation(s):`));
+    const grouped = activeViolations.reduce((acc, v) => {
+        const key = v.type === "forbidden-package"
+            ? `forbidden-package:${v.importedLayer}`
+            : v.type === "file-location"
+                ? `file-location`
+                : `${v.fromLayer} -> ${v.importedLayer}`;
         if (!acc[key])
             acc[key] = [];
         acc[key].push(v);
@@ -124,17 +290,40 @@ function reportViolations(violations, options = {}) {
     Object.keys(grouped).forEach(key => {
         const group = grouped[key];
         const v = group[0];
-        const color = v.severity === "error" ? chalk_1.default.red : chalk_1.default.yellow;
-        console.log(color.bold(`\n[${v.type.toUpperCase()}] ${v.fromLayer} depends on ${v.importedLayer}`));
+        const color = v.severity === "error" ? chalk_1.default.red : v.severity === "warning" ? chalk_1.default.yellow : chalk_1.default.blue;
+        const icon = v.severity === "error" ? "❌" : v.severity === "warning" ? "⚠️" : "ℹ️";
+        if (v.type === "forbidden-package") {
+            console.log(color.bold(`\n${icon} [FORBIDDEN PACKAGE] ${v.importedLayer}`));
+        }
+        else if (v.type === "file-location") {
+            console.log(color.bold(`\n${icon} [FILE LOCATION] Misplaced files`));
+        }
+        else {
+            console.log(color.bold(`\n${icon} [${v.type.toUpperCase()}] ${v.fromLayer} depends on ${v.importedLayer}`));
+        }
         group.forEach(item => {
-            console.log(chalk_1.default.gray(`   - ${item.file} imports '${item.importPath}'`));
+            const location = item.line ? `:${item.line}:${item.column || 1}` : '';
+            console.log(chalk_1.default.gray(`   • ${item.file}${location}`));
+            if (item.message) {
+                console.log(chalk_1.default.gray(`     ${item.message}`));
+            }
+            else {
+                console.log(chalk_1.default.gray(`     imports '${item.importPath}'`));
+            }
         });
     });
+    if (ignoredViolations.length > 0) {
+        console.log(chalk_1.default.gray(`\n📝 ${ignoredViolations.length} violation(s) ignored via @archforge-ignore`));
+    }
     if (options.outputFile) {
         const absoluteOutput = path_1.default.resolve(options.outputFile);
         const ext = path_1.default.extname(absoluteOutput).toLowerCase();
         const content = ext === ".json" ? JSON.stringify(violations, null, 2) :
-            violations.map(v => `[${v.severity.toUpperCase()}] ${v.fromLayer} -> ${v.importedLayer} in ${v.file}`).join("\n");
+            violations.map(v => {
+                const status = v.ignored ? '[IGNORED] ' : '';
+                const location = v.line ? `:${v.line}` : '';
+                return `${status}[${v.severity.toUpperCase()}] ${v.fromLayer} -> ${v.importedLayer} in ${v.file}${location}`;
+            }).join("\n");
         fs_extra_1.default.writeFileSync(absoluteOutput, content, "utf-8");
         console.log(chalk_1.default.blueBright(`\n📄 Detailed report saved to ${absoluteOutput}`));
     }

package/dist/cli/interactive.js

@@ -27,14 +27,20 @@ async function interactiveCLI() {
             { title: "JavaScript", value: "js" },
         ],
     });
+    // NestJS only supports TypeScript
+    const frameworkChoices = langResponse.language === "ts"
+        ? [
+            { title: "NestJS", value: "nestjs" },
+            { title: "Express", value: "express" },
+        ]
+        : [
+            { title: "Express", value: "express" },
+        ];
     const frameworkResponse = await (0, prompts_1.default)({
         type: "select",
         name: "framework",
         message: "Select framework:",
-        choices: [
-            { title: "NestJS", value: "nestjs" },
-            { title: "Express", value: "express" },
-        ],
+        choices: frameworkChoices,
     });
     const archResponse = await (0, prompts_1.default)({
         type: "select",

package/dist/core/VersionManifest.js

@@ -13,6 +13,16 @@ exports.NodePackageVersions = {
     uuid: "9.0.1",
     zod: "3.23.8",
     "http-status-codes": "2.3.0",
+    // Authentication
+    jsonwebtoken: "^9.0.2",
+    bcrypt: "^5.1.1",
+    "@types/jsonwebtoken": "^9.0.6",
+    "@types/bcrypt": "^5.0.2",
+    "passport-jwt": "^4.0.1",
+    "@types/passport-jwt": "^4.0.1",
+    "@nestjs/jwt": "^10.2.0",
+    "@nestjs/passport": "^10.0.3",
+    passport: "^0.7.0",
     // NestJS (v11)
     "@nestjs/common": "^11.0.0",
     "@nestjs/core": "^11.0.0",

package/dist/core/architecture/parser.js

@@ -41,6 +41,12 @@ function mergeArchitectures(base, child) {
         project: { ...base.project, ...child.project },
         metadata: { ...base.metadata, ...child.metadata },
         layers: Array.from(layerMap.values()),
+        rules: { ...base.rules, ...child.rules },
+        naming: { ...base.naming, ...child.naming },
+        ignore: {
+            files: [...(base.ignore?.files || []), ...(child.ignore?.files || [])],
+            patterns: [...(base.ignore?.patterns || []), ...(child.ignore?.patterns || [])],
+        },
     };
 }
 // --- MAIN FUNCTIONS ---
@@ -66,11 +72,27 @@ function loadArchitecture(filePath) {
         }
     }
     catch (e) {
-        throw new Error(`Syntax error in ${filePath}: ${e.message}`);
+        throw new Error(`Syntax error in ${filePath}:\n` +
+            `${e.message}\n\n` +
+            chalk_1.default.yellow(`💡 Tip: Validate your YAML/JSON syntax at https://jsonlint.com or https://yamlvalidator.com`));
     }
     // 3. Handle Inheritance (Extends)
     if (parsed.extends) {
-        const parentPath = path_1.default.resolve(path_1.default.dirname(absolutePath), parsed.extends);
+        let parentPath;
+        // Support npm package extends (e.g., "@company/archforge-config")
+        if (parsed.extends.startsWith('@') || parsed.extends.startsWith('npm:')) {
+            try {
+                const packageName = parsed.extends.replace('npm:', '');
+                parentPath = require.resolve(packageName);
+            }
+            catch {
+                throw new Error(`Cannot resolve extends package: ${parsed.extends}\n\n` +
+                    chalk_1.default.yellow(`💡 Make sure the package is installed: npm install ${parsed.extends}`));
+            }
+        }
+        else {
+            parentPath = path_1.default.resolve(path_1.default.dirname(absolutePath), parsed.extends);
+        }
         console.log(chalk_1.default.gray(`   ↳ Extending configuration from: ${parsed.extends}`));
         const parentArch = loadArchitecture(parentPath);
         const { extends: _, ...childConfig } = parsed;
@@ -79,12 +101,18 @@ function loadArchitecture(filePath) {
     // 4. Validate Schema
     try {
         const validated = schema_1.architectureSchema.parse(parsed);
+        // 5. Validate layer cross-references (canImport, forbiddenImports)
+        (0, schema_1.validateLayerReferences)(validated);
         return processArchitecturePlaceholders(validated);
     }
     catch (err) {
         if (err instanceof zod_1.z.ZodError) {
-            const issues = err.issues.map(i => ` - ${i.path.join('.')}: ${i.message}`).join('\n');
-            throw new Error(`Invalid architecture configuration:\n${issues}`);
+            const issues = err.issues.map(i => {
+                const path = i.path.join('.');
+                return ` - ${chalk_1.default.red(path)}: ${i.message}`;
+            }).join('\n');
+            throw new Error(`${chalk_1.default.red.bold('Invalid architecture configuration:')}\n\n${issues}\n\n` +
+                chalk_1.default.yellow(`💡 Check the documentation: archforge docs`));
         }
         throw err;
     }

package/dist/core/architecture/schema.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.architectureSchema = exports.customStructureSchema = exports.rulesSchema = exports.namingSchema = exports.metadataSchema = exports.layerSchema = void 0;
+exports.architectureSchema = exports.ignoreSchema = exports.customStructureSchema = exports.rulesSchema = exports.importRulesSchema = exports.complexityRulesSchema = exports.forbiddenPackageSchema = exports.fileLocationRuleSchema = exports.namingSchema = exports.namingPatternSchema = exports.metadataSchema = exports.layerSchema = void 0;
+exports.validateLayerReferences = validateLayerReferences;
 // src/core/architecture/schema.ts
 const zod_1 = require("zod");
+// Layer schema with enhanced validation
 exports.layerSchema = zod_1.z.object({
-    name: zod_1.z.string().min(1),
-    path: zod_1.z.string().min(1),
+    name: zod_1.z.string().min(1, "Layer name is required"),
+    path: zod_1.z.string().min(1, "Layer path is required").refine((p) => !p.startsWith('/'), "Layer path must be relative (no leading slash)"),
     description: zod_1.z.string().optional(),
     allowedImports: zod_1.z.array(zod_1.z.string()).optional(),
     forbiddenImports: zod_1.z.array(zod_1.z.string()).optional(),
@@ -21,21 +23,62 @@ exports.metadataSchema = zod_1.z.object({
     modules: zod_1.z.array(zod_1.z.string()).optional(),
     version: zod_1.z.string().optional(),
 });
+// Enhanced naming schema with regex pattern support
+exports.namingPatternSchema = zod_1.z.object({
+    type: zod_1.z.string(),
+    match: zod_1.z.string(),
+    message: zod_1.z.string().optional(),
+});
 exports.namingSchema = zod_1.z.object({
     services: zod_1.z.string().optional(),
     repositories: zod_1.z.string().optional(),
     controllers: zod_1.z.string().optional(),
     entities: zod_1.z.string().optional(),
+    enforcePatterns: zod_1.z.boolean().optional(),
+    patterns: zod_1.z.array(exports.namingPatternSchema).optional(),
+});
+// File location rules schema
+exports.fileLocationRuleSchema = zod_1.z.object({
+    pattern: zod_1.z.string(),
+    allowedPaths: zod_1.z.array(zod_1.z.string()),
+    severity: zod_1.z.enum(['error', 'warning', 'info']).default('error'),
+    message: zod_1.z.string().optional(),
+});
+// Forbidden package rule schema
+exports.forbiddenPackageSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    message: zod_1.z.string().optional(),
+    severity: zod_1.z.enum(['error', 'warning']).default('error'),
 });
+// Complexity rules schema
+exports.complexityRulesSchema = zod_1.z.object({
+    maxFileLines: zod_1.z.number().positive().optional(),
+    maxFunctionLines: zod_1.z.number().positive().optional(),
+    maxCyclomaticComplexity: zod_1.z.number().positive().optional(),
+});
+// Import rules schema
+exports.importRulesSchema = zod_1.z.object({
+    forbiddenPackages: zod_1.z.array(exports.forbiddenPackageSchema).optional(),
+    requireAbsoluteImports: zod_1.z.boolean().optional(),
+});
+// Enhanced rules schema
 exports.rulesSchema = zod_1.z.object({
     forbidDirectDbAccess: zod_1.z.boolean().optional(),
     forbidFrameworkInDomain: zod_1.z.boolean().optional(),
     enforceLayerBoundaries: zod_1.z.boolean().optional(),
+    fileLocations: zod_1.z.array(exports.fileLocationRuleSchema).optional(),
+    imports: exports.importRulesSchema.optional(),
+    complexity: exports.complexityRulesSchema.optional(),
 });
 exports.customStructureSchema = zod_1.z.object({
     enabled: zod_1.z.boolean(),
     folders: zod_1.z.array(zod_1.z.object({ path: zod_1.z.string() })),
 });
+// Ignore configuration schema
+exports.ignoreSchema = zod_1.z.object({
+    files: zod_1.z.array(zod_1.z.string()).optional(),
+    patterns: zod_1.z.array(zod_1.z.string()).optional(),
+});
 exports.architectureSchema = zod_1.z.object({
     version: zod_1.z.string().default("1.0"),
     name: zod_1.z.string(),
@@ -45,9 +88,76 @@ exports.architectureSchema = zod_1.z.object({
         root: zod_1.z.string().optional(),
     }),
     metadata: exports.metadataSchema,
-    layers: zod_1.z.array(exports.layerSchema),
+    layers: zod_1.z.array(exports.layerSchema).min(1, "At least one layer must be defined"),
     naming: exports.namingSchema.optional(),
     rules: exports.rulesSchema.optional(),
     customStructure: exports.customStructureSchema.optional(),
     strict: zod_1.z.boolean().optional(),
+    ignore: exports.ignoreSchema.optional(),
 });
+/**
+ * Validates that all layer references in canImport exist
+ */
+function validateLayerReferences(config) {
+    const layerNames = new Set(config.layers.map(l => l.name));
+    for (const layer of config.layers) {
+        const imports = layer.canImport || layer.allowedImports || [];
+        for (const importRef of imports) {
+            if (!layerNames.has(importRef)) {
+                const suggestions = findSimilarNames(importRef, [...layerNames]);
+                const suggestionText = suggestions.length > 0
+                    ? `\n\nDid you mean: "${suggestions[0]}"?`
+                    : '';
+                throw new Error(`Layer "${layer.name}" references unknown layer "${importRef}" in canImport.${suggestionText}\n\n` +
+                    `Available layers: ${[...layerNames].join(', ')}`);
+            }
+        }
+        // Also check forbiddenImports
+        for (const forbidden of layer.forbiddenImports || []) {
+            if (!layerNames.has(forbidden)) {
+                const suggestions = findSimilarNames(forbidden, [...layerNames]);
+                const suggestionText = suggestions.length > 0
+                    ? `\n\nDid you mean: "${suggestions[0]}"?`
+                    : '';
+                throw new Error(`Layer "${layer.name}" references unknown layer "${forbidden}" in forbiddenImports.${suggestionText}\n\n` +
+                    `Available layers: ${[...layerNames].join(', ')}`);
+            }
+        }
+    }
+}
+/**
+ * Find similar names using Levenshtein distance
+ */
+function findSimilarNames(target, candidates) {
+    return candidates
+        .map(candidate => ({
+        name: candidate,
+        distance: levenshteinDistance(target.toLowerCase(), candidate.toLowerCase())
+    }))
+        .filter(item => item.distance <= 3) // Max 3 character difference
+        .sort((a, b) => a.distance - b.distance)
+        .map(item => item.name);
+}
+/**
+ * Calculate Levenshtein distance between two strings
+ */
+function levenshteinDistance(a, b) {
+    const matrix = [];
+    for (let i = 0; i <= b.length; i++) {
+        matrix[i] = [i];
+    }
+    for (let j = 0; j <= a.length; j++) {
+        matrix[0][j] = j;
+    }
+    for (let i = 1; i <= b.length; i++) {
+        for (let j = 1; j <= a.length; j++) {
+            if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                matrix[i][j] = matrix[i - 1][j - 1];
+            }
+            else {
+                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+            }
+        }
+    }
+    return matrix[b.length][a.length];
+}