@sun-asterisk/sunlint 1.3.33 → 1.3.35

package/engines/arch-detect/rules/modular/m001-feature-modules.js

@@ -0,0 +1,238 @@
+"use strict";
+/**
+ * M001: Multiple Feature Modules Exist
+ * Xác nhận có nhiều modules độc lập với cấu trúc tương tự
+ */
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.M001FeatureModules = void 0;
+const enums_1 = require("../../types/enums");
+const file_scanner_1 = require("../../utils/file-scanner");
+const base_rule_1 = require("../base-rule");
+const rule_registry_1 = require("../rule-registry");
+const rule = (0, base_rule_1.createRule)('M001', 'Multiple Feature Modules Exist', 'Xác nhận có nhiều modules độc lập với cấu trúc tương tự (>= 3 modules)', enums_1.RuleCategory.CORE, 0.18, [enums_1.PatternType.MODULAR], {
+    folderPatterns: [
+        'features/*',
+        'modules/*',
+        'feature/*',
+        'packages/*',
+        'libs/*',
+        'src/features/*',
+        'src/modules/*',
+        'app/modules/*',
+    ],
+}, {
+    isKeyIndicator: true,
+    tags: ['modular', 'feature-modules'],
+});
+let M001FeatureModules = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var M001FeatureModules = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = rule;
+        }
+        async customDetection(context) {
+            const matches = [];
+            const modules = [];
+            // Look for module container folders
+            const moduleContainers = ['features', 'modules', 'feature', 'packages', 'libs', 'apps'];
+            for (const container of moduleContainers) {
+                const containerDirs = file_scanner_1.FileScanner.findFoldersByPattern(context.directoryTree, new RegExp(`^${container}$`, 'i'));
+                for (const containerDir of containerDirs) {
+                    // Each subdirectory is a potential module
+                    for (const subDir of containerDir.subdirectories) {
+                        const structure = this.analyzeModuleStructure(subDir);
+                        if (structure.subfolders.length >= 1 || structure.fileTypes.size >= 2) {
+                            modules.push(structure);
+                        }
+                    }
+                }
+            }
+            // Also check src/modules, src/features patterns
+            const srcModuleDirs = file_scanner_1.FileScanner.findFoldersByPattern(context.directoryTree, /^src\/(modules|features)$/i);
+            for (const srcDir of srcModuleDirs) {
+                for (const subDir of srcDir.subdirectories) {
+                    const structure = this.analyzeModuleStructure(subDir);
+                    if (structure.subfolders.length >= 1 || structure.fileTypes.size >= 2) {
+                        // Avoid duplicates
+                        if (!modules.some((m) => m.path === structure.path)) {
+                            modules.push(structure);
+                        }
+                    }
+                }
+            }
+            // Angular pattern: feature modules in src/app/{feature}
+            // Each subfolder of src/app (except core, shared, environments, assets) can be a feature module
+            const excludedAppFolders = ['core', 'shared', 'environments', 'assets', 'styles'];
+            const srcAppDirs = file_scanner_1.FileScanner.findFoldersByPattern(context.directoryTree, /^(src\/app|app)$/i);
+            for (const appDir of srcAppDirs) {
+                for (const subDir of appDir.subdirectories) {
+                    // Skip excluded folders
+                    if (excludedAppFolders.includes(subDir.name.toLowerCase()))
+                        continue;
+                    const structure = this.analyzeModuleStructure(subDir);
+                    // Angular modules typically have a .module.ts file
+                    if (structure.fileTypes.has('module') ||
+                        structure.subfolders.length >= 1 ||
+                        structure.fileTypes.size >= 2) {
+                        // Avoid duplicates
+                        if (!modules.some((m) => m.path === structure.path)) {
+                            modules.push(structure);
+                        }
+                    }
+                }
+            }
+            // Check structure similarity
+            const similarModules = this.findSimilarModules(modules);
+            for (const mod of similarModules.slice(0, 10)) {
+                matches.push({
+                    type: enums_1.MatchType.FOLDER,
+                    path: mod.path,
+                    matchedPattern: `Feature module: ${mod.name}`,
+                    snippet: `Subfolders: ${mod.subfolders.join(', ') || 'none'}`,
+                });
+            }
+            // Calculate score
+            let score = 0;
+            if (similarModules.length >= 5)
+                score = 1;
+            else if (similarModules.length === 4)
+                score = 0.9;
+            else if (similarModules.length === 3)
+                score = 0.8;
+            else if (similarModules.length === 2)
+                score = 0.4;
+            else if (similarModules.length === 1)
+                score = 0.1;
+            return { matches, violations: [], score };
+        }
+        analyzeModuleStructure(dir) {
+            const subfolders = dir.subdirectories.map((d) => d.name);
+            const fileTypes = new Set();
+            for (const file of dir.files) {
+                // Get file type from naming pattern
+                if (/\.component\./i.test(file.fileName))
+                    fileTypes.add('component');
+                else if (/\.service\./i.test(file.fileName))
+                    fileTypes.add('service');
+                else if (/\.controller\./i.test(file.fileName))
+                    fileTypes.add('controller');
+                else if (/\.module\./i.test(file.fileName))
+                    fileTypes.add('module');
+                else if (/\.model\./i.test(file.fileName) || /\.entity\./i.test(file.fileName))
+                    fileTypes.add('model');
+                else if (/\.repository\./i.test(file.fileName))
+                    fileTypes.add('repository');
+                else if (/index\./i.test(file.fileName))
+                    fileTypes.add('barrel');
+            }
+            // Check subdirectories for types
+            for (const subfolder of subfolders) {
+                const lowerName = subfolder.toLowerCase();
+                if (/component/i.test(lowerName))
+                    fileTypes.add('component');
+                if (/service/i.test(lowerName))
+                    fileTypes.add('service');
+                if (/model/i.test(lowerName))
+                    fileTypes.add('model');
+                if (/controller/i.test(lowerName))
+                    fileTypes.add('controller');
+            }
+            return {
+                name: dir.name,
+                path: dir.relativePath,
+                subfolders,
+                fileTypes,
+            };
+        }
+        findSimilarModules(modules) {
+            if (modules.length < 2)
+                return modules;
+            // Group modules by structure pattern
+            const patterns = new Map();
+            for (const mod of modules) {
+                // Create a signature from subfolders and file types
+                const signature = [
+                    ...Array.from(mod.fileTypes).sort(),
+                    ...mod.subfolders.map((s) => s.toLowerCase()).sort(),
+                ].join('|');
+                if (!patterns.has(signature)) {
+                    patterns.set(signature, []);
+                }
+                patterns.get(signature).push(mod);
+            }
+            // Find the largest group of similar modules
+            let largestGroup = [];
+            for (const group of patterns.values()) {
+                if (group.length > largestGroup.length) {
+                    largestGroup = group;
+                }
+            }
+            // If no clear pattern, return all modules that have at least some structure
+            if (largestGroup.length < 2) {
+                return modules.filter((m) => m.subfolders.length >= 1 || m.fileTypes.size >= 2);
+            }
+            return largestGroup;
+        }
+        getMetadata(context, matches) {
+            return {
+                ...super.getMetadata(context, matches),
+                moduleCount: matches.filter((m) => m.matchedPattern?.startsWith('Feature module')).length,
+            };
+        }
+    };
+    __setFunctionName(_classThis, "M001FeatureModules");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        M001FeatureModules = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return M001FeatureModules = _classThis;
+})();
+exports.M001FeatureModules = M001FeatureModules;
+exports.default = M001FeatureModules;
+//# sourceMappingURL=m001-feature-modules.js.map

package/engines/arch-detect/rules/modular/m002-core-module.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * M002: Core/Shared Module Exists
+ * Xác nhận có shared module chứa common functionality
+ */
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.M002CoreModule = void 0;
+const enums_1 = require("../../types/enums");
+const file_scanner_1 = require("../../utils/file-scanner");
+const base_rule_1 = require("../base-rule");
+const rule_registry_1 = require("../rule-registry");
+const rule = (0, base_rule_1.createRule)('M002', 'Core/Shared Module Exists', 'Xác nhận có shared module chứa common functionality (utils, helpers, shared services)', enums_1.RuleCategory.CORE, 0.14, [enums_1.PatternType.MODULAR], {
+    folderPatterns: ['core', 'shared', 'common', 'lib', 'infrastructure', 'foundation', 'utils'],
+}, {
+    isKeyIndicator: true,
+    tags: ['modular', 'core', 'shared'],
+});
+let M002CoreModule = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var M002CoreModule = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = rule;
+        }
+        async customDetection(context) {
+            const matches = [];
+            let hasCore = false;
+            let hasShared = false;
+            let hasCommon = false;
+            let contentScore = 0;
+            const corePatterns = [
+                { name: 'core', folder: /^(src\/)?core$/i },
+                { name: 'shared', folder: /^(src\/)?shared$/i },
+                { name: 'common', folder: /^(src\/)?common$/i },
+                { name: 'lib', folder: /^(src\/)?lib$/i },
+                { name: 'infrastructure', folder: /^(src\/)?infrastructure$/i },
+                { name: 'foundation', folder: /^(src\/)?foundation$/i },
+            ];
+            for (const pattern of corePatterns) {
+                const found = file_scanner_1.FileScanner.findFoldersByPattern(context.directoryTree, pattern.folder);
+                if (found.length > 0) {
+                    const folder = found[0];
+                    matches.push({
+                        type: enums_1.MatchType.FOLDER,
+                        path: folder.relativePath,
+                        matchedPattern: `${pattern.name} module`,
+                    });
+                    if (pattern.name === 'core')
+                        hasCore = true;
+                    if (pattern.name === 'shared')
+                        hasShared = true;
+                    if (pattern.name === 'common')
+                        hasCommon = true;
+                    // Check content indicators
+                    const contentIndicators = this.checkCoreContent(folder, context);
+                    contentScore += contentIndicators;
+                }
+            }
+            // Check for utils/helpers files
+            const utilFiles = context.files.filter((f) => /utils?\.(ts|js|java|py|go|cs)$/i.test(f.fileName) ||
+                /helpers?\.(ts|js|java|py|go|cs)$/i.test(f.fileName) ||
+                /constants?\.(ts|js|java|py|go|cs)$/i.test(f.fileName));
+            if (utilFiles.length > 0) {
+                matches.push({
+                    type: enums_1.MatchType.FILE,
+                    path: '',
+                    matchedPattern: `${utilFiles.length} utility files found`,
+                });
+                contentScore += 0.2;
+            }
+            // Calculate score
+            let score = 0;
+            if (hasCore || hasShared)
+                score = 0.5;
+            else if (hasCommon)
+                score = 0.3;
+            score += Math.min(contentScore, 0.5);
+            score = Math.min(score, 1);
+            return { matches, violations: [], score };
+        }
+        checkCoreContent(folder, _context) {
+            let score = 0;
+            // Check for common file types
+            const patterns = [
+                { pattern: /utils?/i, weight: 0.1 },
+                { pattern: /helpers?/i, weight: 0.1 },
+                { pattern: /constants?/i, weight: 0.05 },
+                { pattern: /http.*client/i, weight: 0.15 },
+                { pattern: /auth.*service/i, weight: 0.15 },
+                { pattern: /logger/i, weight: 0.1 },
+                { pattern: /config/i, weight: 0.1 },
+                { pattern: /base/i, weight: 0.1 },
+            ];
+            for (const file of folder.files) {
+                for (const p of patterns) {
+                    if (p.pattern.test(file.fileName)) {
+                        score += p.weight;
+                    }
+                }
+            }
+            return score;
+        }
+        getMetadata(context, matches) {
+            const coreModules = matches
+                .filter((m) => m.matchedPattern?.includes('module'))
+                .map((m) => m.matchedPattern?.split(' ')[0]);
+            return {
+                ...super.getMetadata(context, matches),
+                coreModules,
+                hasCoreModule: coreModules.includes('core'),
+                hasSharedModule: coreModules.includes('shared'),
+            };
+        }
+    };
+    __setFunctionName(_classThis, "M002CoreModule");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        M002CoreModule = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return M002CoreModule = _classThis;
+})();
+exports.M002CoreModule = M002CoreModule;
+exports.default = M002CoreModule;
+//# sourceMappingURL=m002-core-module.js.map

package/engines/arch-detect/rules/modular/m003-module-declaration.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * M003: Module Declaration/Definition
+ * Xác nhận modules được khai báo formal
+ */
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.M003ModuleDeclaration = void 0;
+const enums_1 = require("../../types/enums");
+const base_rule_1 = require("../base-rule");
+const rule_registry_1 = require("../rule-registry");
+const rule = (0, base_rule_1.createRule)('M003', 'Module Declaration/Definition', 'Xác nhận modules được khai báo formal (@NgModule, @Module, module-info.java, etc.)', enums_1.RuleCategory.CORE, 0.13, [enums_1.PatternType.MODULAR], {
+    filePatterns: ['*.module.ts', '*.module.js', 'module-info.java', 'project.json'],
+    codePatterns: [
+        {
+            language: enums_1.Language.TYPESCRIPT,
+            type: enums_1.CodePatternType.ANNOTATION,
+            pattern: /@NgModule\s*\(/,
+        },
+        { language: enums_1.Language.TYPESCRIPT, type: enums_1.CodePatternType.ANNOTATION, pattern: /@Module\s*\(/ },
+        { language: enums_1.Language.JAVA, type: enums_1.CodePatternType.PATTERN, pattern: /module\s+[\w.]+\s*\{/ },
+    ],
+}, {
+    isKeyIndicator: true,
+    tags: ['modular', 'declaration'],
+});
+let M003ModuleDeclaration = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var M003ModuleDeclaration = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = rule;
+        }
+        async customDetection(context) {
+            const matches = [];
+            let moduleDeclarations = 0;
+            // Check for Angular/NestJS module files
+            const moduleFiles = context.files.filter((f) => /\.module\.(ts|js)$/i.test(f.fileName));
+            for (const file of moduleFiles.slice(0, 10)) {
+                try {
+                    const content = await context.helpers.readFile(file.absolutePath);
+                    if (/@NgModule\s*\(/.test(content)) {
+                        matches.push({
+                            type: enums_1.MatchType.CODE,
+                            path: file.relativePath,
+                            matchedPattern: 'Angular NgModule',
+                        });
+                        moduleDeclarations++;
+                    }
+                    else if (/@Module\s*\(/.test(content)) {
+                        matches.push({
+                            type: enums_1.MatchType.CODE,
+                            path: file.relativePath,
+                            matchedPattern: 'NestJS Module',
+                        });
+                        moduleDeclarations++;
+                    }
+                }
+                catch {
+                    // Skip
+                }
+            }
+            // Check for Java 9+ modules
+            const moduleInfoFiles = context.files.filter((f) => f.fileName === 'module-info.java');
+            for (const file of moduleInfoFiles) {
+                matches.push({
+                    type: enums_1.MatchType.FILE,
+                    path: file.relativePath,
+                    matchedPattern: 'Java Module',
+                });
+                moduleDeclarations++;
+            }
+            // Check for Nx/Lerna project.json
+            const projectJsonFiles = context.files.filter((f) => f.fileName === 'project.json' && !f.relativePath.includes('node_modules'));
+            for (const file of projectJsonFiles.slice(0, 10)) {
+                matches.push({
+                    type: enums_1.MatchType.CONFIG,
+                    path: file.relativePath,
+                    matchedPattern: 'Nx Project',
+                });
+                moduleDeclarations++;
+            }
+            // Check for Android library modules (build.gradle with library plugin)
+            const buildGradleFiles = context.files.filter((f) => f.fileName === 'build.gradle' || f.fileName === 'build.gradle.kts');
+            for (const file of buildGradleFiles.slice(0, 10)) {
+                try {
+                    const content = await context.helpers.readFile(file.absolutePath);
+                    if (/com\.android\.library/i.test(content)) {
+                        matches.push({
+                            type: enums_1.MatchType.CONFIG,
+                            path: file.relativePath,
+                            matchedPattern: 'Android Library Module',
+                        });
+                        moduleDeclarations++;
+                    }
+                }
+                catch {
+                    // Skip
+                }
+            }
+            // Check for .NET project references
+            const csprojFiles = context.files.filter((f) => f.extension === '.csproj');
+            if (csprojFiles.length > 1) {
+                for (const file of csprojFiles.slice(0, 5)) {
+                    matches.push({
+                        type: enums_1.MatchType.CONFIG,
+                        path: file.relativePath,
+                        matchedPattern: '.NET Project',
+                    });
+                    moduleDeclarations++;
+                }
+            }
+            // Calculate score
+            let score = 0;
+            if (moduleDeclarations >= 3)
+                score = 1;
+            else if (moduleDeclarations >= 2)
+                score = 0.7;
+            else if (moduleDeclarations >= 1)
+                score = 0.4;
+            return { matches, violations: [], score };
+        }
+        getMetadata(context, matches) {
+            const moduleTypes = matches.map((m) => m.matchedPattern);
+            const uniqueTypes = [...new Set(moduleTypes)];
+            return {
+                ...super.getMetadata(context, matches),
+                moduleDeclarationCount: matches.length,
+                moduleTypes: uniqueTypes,
+            };
+        }
+    };
+    __setFunctionName(_classThis, "M003ModuleDeclaration");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        M003ModuleDeclaration = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return M003ModuleDeclaration = _classThis;
+})();
+exports.M003ModuleDeclaration = M003ModuleDeclaration;
+exports.default = M003ModuleDeclaration;
+//# sourceMappingURL=m003-module-declaration.js.map