@sun-asterisk/sunlint 1.3.34 → 1.3.35

package/engines/arch-detect/rules/base-rule.js

@@ -0,0 +1,187 @@
+"use strict";
+/**
+ * Base Rule Class
+ * Abstract class cho tất cả rules
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseRule = void 0;
+exports.createRule = createRule;
+const enums_1 = require("../types/enums");
+const pattern_matcher_1 = require("../utils/pattern-matcher");
+/**
+ * Abstract base class cho tất cả rule implementations
+ */
+class BaseRule {
+    constructor() {
+        /** Pattern matcher instance */
+        this.patternMatcher = null;
+    }
+    /**
+     * Khởi tạo pattern matcher từ context
+     */
+    initializePatternMatcher(context) {
+        this.patternMatcher = new pattern_matcher_1.PatternMatcher(context.projectInfo.projectRoot);
+    }
+    /**
+     * Execute rule và trả về kết quả
+     */
+    async execute(context) {
+        const startTime = Date.now();
+        this.initializePatternMatcher(context);
+        try {
+            // Run detection
+            const matches = [];
+            const violations = [];
+            let score = 0;
+            // Match folder patterns
+            if (this.rule.detection.folderPatterns?.length) {
+                const folderResult = await this.patternMatcher.matchFolderPatterns(this.rule.detection.folderPatterns, context.directoryTree);
+                matches.push(...folderResult.matches);
+                score += folderResult.score * 0.3;
+            }
+            // Match file patterns
+            if (this.rule.detection.filePatterns?.length) {
+                const fileResult = await this.patternMatcher.matchFilePatterns(this.rule.detection.filePatterns, context.files);
+                matches.push(...fileResult.matches);
+                score += fileResult.score * 0.3;
+            }
+            // Match code patterns
+            if (this.rule.detection.codePatterns?.length) {
+                const codeResult = await this.patternMatcher.matchCodePatterns(this.rule.detection.codePatterns, context.files);
+                matches.push(...codeResult.matches);
+                score += codeResult.score * 0.4;
+            }
+            // Match config patterns
+            if (this.rule.detection.configPatterns?.length) {
+                const configResult = await this.patternMatcher.matchConfigPatterns(this.rule.detection.configPatterns, context.files);
+                matches.push(...configResult.matches);
+                score += configResult.score * 0.2;
+            }
+            // Custom detection
+            const customResult = await this.customDetection(context);
+            if (customResult) {
+                matches.push(...customResult.matches);
+                violations.push(...customResult.violations);
+                score = customResult.score ?? score;
+            }
+            // Normalize score
+            score = Math.min(Math.max(score, 0), 1);
+            // Calculate final result
+            const passed = this.determinePass(score, matches);
+            const confidence = this.calculateConfidence(matches, context);
+            const weightedScore = score * this.rule.weight;
+            const executionTime = Date.now() - startTime;
+            return {
+                ruleId: this.rule.id,
+                ruleName: this.rule.name,
+                passed,
+                score,
+                weightedScore,
+                confidence,
+                matches,
+                violations,
+                metadata: this.getMetadata(context, matches),
+                executionTime,
+            };
+        }
+        catch (error) {
+            const executionTime = Date.now() - startTime;
+            return {
+                ruleId: this.rule.id,
+                ruleName: this.rule.name,
+                passed: false,
+                score: 0,
+                weightedScore: 0,
+                confidence: 0,
+                matches: [],
+                violations: [
+                    {
+                        type: 'execution_error',
+                        severity: enums_1.Severity.ERROR,
+                        path: '',
+                        message: `Error executing rule: ${error}`,
+                    },
+                ],
+                metadata: { error: String(error) },
+                executionTime,
+            };
+        }
+    }
+    /**
+     * Custom detection logic - override trong subclass
+     */
+    async customDetection(_context) {
+        return null;
+    }
+    /**
+     * Xác định rule có pass không dựa trên score và matches
+     */
+    determinePass(score, matches) {
+        // Default: pass nếu có ít nhất 1 match và score >= 0.3
+        return matches.length > 0 && score >= 0.3;
+    }
+    /**
+     * Tính confidence dựa trên matches
+     */
+    calculateConfidence(matches, _context) {
+        if (matches.length === 0)
+            return 0;
+        // Base confidence từ số lượng matches
+        let confidence = Math.min(matches.length / 10, 0.5);
+        // Tăng confidence nếu có nhiều loại matches khác nhau
+        const matchTypes = new Set(matches.map((m) => m.type));
+        confidence += matchTypes.size * 0.1;
+        // Tăng confidence nếu matches phân bố đều
+        const pathSet = new Set(matches.map((m) => m.path.split('/')[0]));
+        confidence += Math.min(pathSet.size / 5, 0.2);
+        return Math.min(confidence, 1);
+    }
+    /**
+     * Lấy metadata bổ sung
+     */
+    getMetadata(_context, matches) {
+        return {
+            matchCount: matches.length,
+            uniquePaths: new Set(matches.map((m) => m.path)).size,
+            framework: 'detected',
+        };
+    }
+    /**
+     * Validate rule configuration
+     */
+    validate() {
+        if (!this.rule.id || !this.rule.name) {
+            return false;
+        }
+        if (this.rule.weight < 0 || this.rule.weight > 1) {
+            return false;
+        }
+        return true;
+    }
+}
+exports.BaseRule = BaseRule;
+/**
+ * Helper để tạo rule definition
+ */
+function createRule(id, name, description, category, weight, applicableTo, detection, options) {
+    return {
+        id,
+        name,
+        description,
+        category,
+        weight,
+        applicableTo,
+        detection,
+        scoring: {
+            fullScore: 1,
+            partialScoring: options?.partialScoring ?? true,
+            partialThresholds: options?.partialThresholds,
+        },
+        requires: options?.requires,
+        conflicts: options?.conflicts,
+        isKeyIndicator: options?.isKeyIndicator,
+        tags: options?.tags,
+    };
+}
+exports.default = BaseRule;
+//# sourceMappingURL=base-rule.js.map

package/engines/arch-detect/rules/index.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Rules Index
+ * Import và export tất cả các rules
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ruleRegistry = exports.RegisterRule = void 0;
+// Rule Infrastructure
+__exportStar(require("./base-rule"), exports);
+// Layered Architecture Rules
+__exportStar(require("./layered"), exports);
+// Modular Architecture Rules
+__exportStar(require("./modular"), exports);
+// Presentation Pattern Rules (MVVM, VIPER)
+__exportStar(require("./presentation"), exports);
+// Project Scanner Rules
+__exportStar(require("./project-scanner"), exports);
+var rule_registry_1 = require("./rule-registry");
+Object.defineProperty(exports, "RegisterRule", { enumerable: true, get: function () { return rule_registry_1.RegisterRule; } });
+Object.defineProperty(exports, "ruleRegistry", { enumerable: true, get: function () { return rule_registry_1.ruleRegistry; } });
+//# sourceMappingURL=index.js.map

package/engines/arch-detect/rules/layered/index.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Layered/MVC Rules Index
+ * Export tất cả Layered Architecture rules (L001-L015)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./l001-presentation-layer"), exports);
+__exportStar(require("./l002-business-layer"), exports);
+__exportStar(require("./l003-data-layer"), exports);
+__exportStar(require("./l004-model-layer"), exports);
+__exportStar(require("./l005-layer-separation"), exports);
+__exportStar(require("./l006-dependency-direction"), exports);
+__exportStar(require("./layered-rules-collection"), exports);
+//# sourceMappingURL=index.js.map

package/engines/arch-detect/rules/layered/l001-presentation-layer.js

@@ -0,0 +1,237 @@
+"use strict";
+/**
+ * L001: Presentation Layer Exists
+ * Xác nhận có tầng xử lý request/response (Controller/Handler)
+ */
+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.L001PresentationLayer = 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)('L001', 'Presentation Layer Exists', 'Xác nhận có tầng xử lý request/response (Controller, Handler, Endpoint)', enums_1.RuleCategory.CORE, 0.16, [enums_1.PatternType.LAYERED], {
+    folderPatterns: [
+        'controllers',
+        'controller',
+        'api',
+        'handlers',
+        'endpoints',
+        'resources',
+        'routes',
+        'Http/Controllers',
+        'presentation',
+    ],
+    filePatterns: ['*Controller.*', '*Handler.*', '*Endpoint.*', '*Resource.*', '*Api.*'],
+    codePatterns: [
+        // Java
+        { language: enums_1.Language.JAVA, type: enums_1.CodePatternType.ANNOTATION, pattern: /@Controller\b/ },
+        { language: enums_1.Language.JAVA, type: enums_1.CodePatternType.ANNOTATION, pattern: /@RestController\b/ },
+        { language: enums_1.Language.JAVA, type: enums_1.CodePatternType.ANNOTATION, pattern: /@RequestMapping\b/ },
+        { language: enums_1.Language.JAVA, type: enums_1.CodePatternType.ANNOTATION, pattern: /@GetMapping\b/ },
+        { language: enums_1.Language.JAVA, type: enums_1.CodePatternType.ANNOTATION, pattern: /@PostMapping\b/ },
+        // TypeScript/JavaScript
+        {
+            language: enums_1.Language.TYPESCRIPT,
+            type: enums_1.CodePatternType.ANNOTATION,
+            pattern: /@Controller\s*\(/,
+        },
+        { language: enums_1.Language.TYPESCRIPT, type: enums_1.CodePatternType.ANNOTATION, pattern: /@Get\s*\(/ },
+        { language: enums_1.Language.TYPESCRIPT, type: enums_1.CodePatternType.ANNOTATION, pattern: /@Post\s*\(/ },
+        {
+            language: enums_1.Language.JAVASCRIPT,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /router\.(get|post|put|delete)\s*\(/,
+        },
+        {
+            language: enums_1.Language.JAVASCRIPT,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /app\.(get|post|put|delete)\s*\(/,
+        },
+        // C#
+        { language: enums_1.Language.CSHARP, type: enums_1.CodePatternType.ANNOTATION, pattern: /\[ApiController\]/ },
+        { language: enums_1.Language.CSHARP, type: enums_1.CodePatternType.ANNOTATION, pattern: /\[HttpGet\]/ },
+        { language: enums_1.Language.CSHARP, type: enums_1.CodePatternType.ANNOTATION, pattern: /\[HttpPost\]/ },
+        // PHP
+        { language: enums_1.Language.PHP, type: enums_1.CodePatternType.CLASS, pattern: /extends\s+Controller\b/ },
+        {
+            language: enums_1.Language.PHP,
+            type: enums_1.CodePatternType.PATTERN,
+            pattern: /Route::(get|post|put|delete)\s*\(/,
+        },
+        // Python
+        { language: enums_1.Language.PYTHON, type: enums_1.CodePatternType.ANNOTATION, pattern: /@app\.route\s*\(/ },
+        { language: enums_1.Language.PYTHON, type: enums_1.CodePatternType.ANNOTATION, pattern: /@api_view\s*\(/ },
+        // Go
+        { language: enums_1.Language.GO, type: enums_1.CodePatternType.PATTERN, pattern: /r\.HandleFunc\s*\(/ },
+        { language: enums_1.Language.GO, type: enums_1.CodePatternType.PATTERN, pattern: /gin\.Context/ },
+        // Ruby
+        {
+            language: enums_1.Language.RUBY,
+            type: enums_1.CodePatternType.CLASS,
+            pattern: /class\s+\w+Controller\s*<\s*ApplicationController/,
+        },
+    ],
+}, {
+    isKeyIndicator: true,
+    tags: ['layered', 'presentation', 'controller'],
+});
+let L001PresentationLayer = (() => {
+    let _classDecorators = [(0, rule_registry_1.RegisterRule)(rule)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = base_rule_1.BaseRule;
+    var L001PresentationLayer = _classThis = class extends _classSuper {
+        constructor() {
+            super(...arguments);
+            this.rule = rule;
+        }
+        async customDetection(context) {
+            const matches = [];
+            let hasFolders = false;
+            let hasFiles = false;
+            let hasCode = false;
+            // Check for controller folders
+            const controllerFolders = [
+                'controllers',
+                'controller',
+                'api',
+                'handlers',
+                'endpoints',
+                'resources',
+                'routes',
+            ];
+            for (const folder of controllerFolders) {
+                const found = context.files.some((f) => f.relativePath.toLowerCase().includes(`/${folder}/`) ||
+                    f.relativePath.toLowerCase().startsWith(`${folder}/`));
+                if (found) {
+                    matches.push({
+                        type: enums_1.MatchType.FOLDER,
+                        path: folder,
+                        matchedPattern: 'Controller folder',
+                    });
+                    hasFolders = true;
+                }
+            }
+            // Check for controller files
+            const controllerFiles = context.files.filter((f) => /Controller\.(ts|js|java|cs|php|py|rb|go)$/i.test(f.fileName) ||
+                /Handler\.(ts|js|java|cs|php|py|rb|go)$/i.test(f.fileName) ||
+                /\.controller\.(ts|js)$/i.test(f.fileName));
+            if (controllerFiles.length > 0) {
+                for (const file of controllerFiles.slice(0, 5)) {
+                    matches.push({
+                        type: enums_1.MatchType.FILE,
+                        path: file.relativePath,
+                        matchedPattern: 'Controller file',
+                    });
+                }
+                hasFiles = true;
+            }
+            // Check for code patterns (sampling first 50 source files)
+            const sourceFiles = context.files
+                .filter((f) => !f.isTest && !f.isConfig && f.language)
+                .slice(0, 50);
+            const codePatterns = [
+                /@Controller\b/,
+                /@RestController\b/,
+                /@Get\s*\(/,
+                /@Post\s*\(/,
+                /router\.(get|post|put|delete)\s*\(/,
+                /app\.(get|post|put|delete)\s*\(/,
+                /\[ApiController\]/,
+                /@app\.route\s*\(/,
+            ];
+            for (const file of sourceFiles) {
+                try {
+                    const content = await context.helpers.readFile(file.absolutePath);
+                    for (const pattern of codePatterns) {
+                        if (pattern.test(content)) {
+                            hasCode = true;
+                            const lineMatch = content.split('\n').findIndex((line) => pattern.test(line));
+                            matches.push({
+                                type: enums_1.MatchType.CODE,
+                                path: file.relativePath,
+                                line: lineMatch + 1,
+                                matchedPattern: 'Controller pattern',
+                            });
+                            break;
+                        }
+                    }
+                    if (hasCode && matches.length >= 10)
+                        break;
+                }
+                catch {
+                    // Skip unreadable files
+                }
+            }
+            // Calculate score based on presence
+            let score = 0;
+            if (hasFolders && hasFiles)
+                score = 1;
+            else if (hasFiles)
+                score = 0.7;
+            else if (hasCode)
+                score = 0.6;
+            else if (hasFolders)
+                score = 0.4;
+            return { matches, violations: [], score };
+        }
+        getMetadata(context, matches) {
+            const controllerCount = matches.filter((m) => m.matchedPattern === 'Controller file').length;
+            return {
+                ...super.getMetadata(context, matches),
+                controllerCount,
+                hasDedicatedFolder: matches.some((m) => m.matchedPattern === 'Controller folder'),
+            };
+        }
+    };
+    __setFunctionName(_classThis, "L001PresentationLayer");
+    (() => {
+        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);
+        L001PresentationLayer = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return L001PresentationLayer = _classThis;
+})();
+exports.L001PresentationLayer = L001PresentationLayer;
+exports.default = L001PresentationLayer;
+//# sourceMappingURL=l001-presentation-layer.js.map