auto-cr-rules 2.0.75 → 2.0.78

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.noSwallowedErrors = exports.noDeepRelativeImports = exports.builtinRules = exports.createRuleContext = exports.toRule = exports.isRule = exports.defineRule = exports.RuleSeverity = void 0;
+exports.noSwallowedErrors = exports.noCircularDependencies = exports.noDeepRelativeImports = exports.builtinRules = exports.createRuleContext = exports.toRule = exports.isRule = exports.defineRule = exports.RuleSeverity = void 0;
 var types_1 = require("./types");
 Object.defineProperty(exports, "RuleSeverity", { enumerable: true, get: function () { return types_1.RuleSeverity; } });
 var types_2 = require("./types");
@@ -12,4 +12,5 @@ Object.defineProperty(exports, "createRuleContext", { enumerable: true, get: fun
 var rules_1 = require("./rules");
 Object.defineProperty(exports, "builtinRules", { enumerable: true, get: function () { return rules_1.builtinRules; } });
 Object.defineProperty(exports, "noDeepRelativeImports", { enumerable: true, get: function () { return rules_1.noDeepRelativeImports; } });
+Object.defineProperty(exports, "noCircularDependencies", { enumerable: true, get: function () { return rules_1.noCircularDependencies; } });
 Object.defineProperty(exports, "noSwallowedErrors", { enumerable: true, get: function () { return rules_1.noSwallowedErrors; } });

package/dist/messages.js

@@ -8,6 +8,10 @@ var ruleTranslations = {
             return "\u5BFC\u5165\u8DEF\u5F84 \"".concat(value, "\"\uFF0C\u4E0D\u80FD\u8D85\u8FC7\u6700\u5927\u5C42\u7EA7").concat(maxDepth);
         },
         swallowedError: function () { return '捕获到的异常未被重新抛出或记录，可能导致问题被静默吞噬。'; },
+        circularDependency: function (_a) {
+            var chain = _a.chain;
+            return "\u68C0\u6D4B\u5230\u5FAA\u73AF\u4F9D\u8D56: ".concat(chain);
+        },
     },
     en: {
         noDeepRelativeImports: function (_a) {
@@ -15,6 +19,10 @@ var ruleTranslations = {
             return "Import path \"".concat(value, "\" must not exceed max depth ").concat(maxDepth);
         },
         swallowedError: function () { return 'Caught exception is neither rethrown nor logged; potential swallowed error detected.'; },
+        circularDependency: function (_a) {
+            var chain = _a.chain;
+            return "Circular dependency detected: ".concat(chain);
+        },
     },
 };
 Object.values(ruleTranslations).forEach(function (messages) { return Object.freeze(messages); });

package/dist/rules/index.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.noSwallowedErrors = exports.noDeepRelativeImports = exports.builtinRules = void 0;
+exports.noSwallowedErrors = exports.noCircularDependencies = exports.noDeepRelativeImports = exports.builtinRules = void 0;
 var noDeepRelativeImports_1 = require("./noDeepRelativeImports");
 Object.defineProperty(exports, "noDeepRelativeImports", { enumerable: true, get: function () { return noDeepRelativeImports_1.noDeepRelativeImports; } });
+var noCircularDependencies_1 = require("./noCircularDependencies");
+Object.defineProperty(exports, "noCircularDependencies", { enumerable: true, get: function () { return noCircularDependencies_1.noCircularDependencies; } });
 var noSwallowedErrors_1 = require("./noSwallowedErrors");
 Object.defineProperty(exports, "noSwallowedErrors", { enumerable: true, get: function () { return noSwallowedErrors_1.noSwallowedErrors; } });
-exports.builtinRules = [noDeepRelativeImports_1.noDeepRelativeImports, noSwallowedErrors_1.noSwallowedErrors];
+exports.builtinRules = [noDeepRelativeImports_1.noDeepRelativeImports, noCircularDependencies_1.noCircularDependencies, noSwallowedErrors_1.noSwallowedErrors];

package/dist/rules/noCircularDependencies.js

@@ -0,0 +1,404 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noCircularDependencies = void 0;
+var fs_1 = __importDefault(require("fs"));
+var path_1 = __importDefault(require("path"));
+var types_1 = require("../types");
+/**
+ * 检测相对路径形成的循环依赖：
+ * - 仅解析 .ts/.tsx/.js/.jsx/.mjs/.cjs；
+ * - 从当前文件的 import 出发，沿依赖图寻找回到自身的路径；
+ * - 输出完整环路链路，便于定位循环发生的文件。
+ */
+var SUPPORTED_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+// 避免在大型仓库里构图过深或过大导致卡顿。
+var MAX_GRAPH_NODES = 2000;
+var MAX_GRAPH_DEPTH = 80;
+// 跨文件缓存解析结果，减少重复 IO 与正则扫描。
+var resolvedImportCache = new Map();
+// 记录已上报的环路（做规范化），避免同一环路重复报错。
+var reportedCycles = new Set();
+exports.noCircularDependencies = (0, types_1.defineRule)('no-circular-dependencies', { tag: 'base', severity: types_1.RuleSeverity.Warning }, function (_a) {
+    var _b, _c;
+    var ast = _a.ast, filePath = _a.filePath, helpers = _a.helpers, language = _a.language, messages = _a.messages, source = _a.source;
+    var origin = path_1.default.resolve(filePath);
+    var root = resolveProjectRoot(origin);
+    var moduleStart = (_c = (_b = ast.span) === null || _b === void 0 ? void 0 : _b.start) !== null && _c !== void 0 ? _c : 0;
+    var lineIndex = buildLineIndex(source);
+    // 先用 SWC 提供的 import 列表初始化当前文件的依赖，保证准确性与性能。
+    resolvedImportCache.set(origin, resolveFromReferences(origin, helpers.imports, root));
+    for (var _i = 0, _d = helpers.imports; _i < _d.length; _i++) {
+        var reference = _d[_i];
+        if (!helpers.isRelativePath(reference.value)) {
+            continue;
+        }
+        var target = resolveImportFile(origin, reference.value, root);
+        if (!target) {
+            continue;
+        }
+        // 从目标模块回溯，如果能再次回到 origin，即存在环路。
+        var pathToOrigin = findPathToOrigin(target, origin, root);
+        if (!pathToOrigin) {
+            continue;
+        }
+        var cycle = __spreadArray([origin], pathToOrigin, true);
+        var cycleKey = buildCycleKey(cycle);
+        if (reportedCycles.has(cycleKey)) {
+            continue;
+        }
+        reportedCycles.add(cycleKey);
+        // 统一输出相对路径，便于直接定位到仓库内文件。
+        var displayChain = formatCycle(cycle, root);
+        var description = messages.circularDependency({ chain: displayChain });
+        var suggestions = language === 'zh'
+            ? [
+                { text: '考虑拆分模块，避免相互依赖。' },
+                { text: '抽取共享逻辑到独立模块以打破循环。' },
+            ]
+            : [
+                { text: 'Split modules to avoid mutual dependencies.' },
+                { text: 'Extract shared logic into a dedicated module to break the cycle.' },
+            ];
+        // 优先使用 SWC 的 span 计算行号，作为高可信位置；失败时再用文本匹配兜底。
+        var computedLine = reference.span
+            ? resolveLine(lineIndex, bytePosToCharIndex(source, moduleStart, reference.span.start))
+            : undefined;
+        var fallbackLine = findImportLine(source, reference.value);
+        var line = selectLineNumber(computedLine, fallbackLine);
+        helpers.reportViolation({
+            description: description,
+            code: displayChain,
+            suggestions: suggestions,
+            span: reference.span,
+            line: line,
+        }, reference.span);
+    }
+});
+// 选择项目根目录：优先使用当前工作目录，找不到则向上寻找最近的 package.json。
+var resolveProjectRoot = function (filePath) {
+    var cwd = path_1.default.resolve(process.cwd());
+    if (isWithinRoot(filePath, cwd)) {
+        return cwd;
+    }
+    var current = path_1.default.dirname(filePath);
+    var last = '';
+    while (current !== last) {
+        if (fs_1.default.existsSync(path_1.default.join(current, 'package.json'))) {
+            return current;
+        }
+        last = current;
+        current = path_1.default.dirname(current);
+    }
+    return cwd;
+};
+// 防止解析路径逃逸到仓库外，避免跨项目误报。
+var isWithinRoot = function (filePath, root) {
+    var relative = path_1.default.relative(root, filePath);
+    return relative === '' || (!relative.startsWith('..') && !path_1.default.isAbsolute(relative));
+};
+// 将当前文件的 import 列表解析为真实文件路径（只处理相对路径）。
+var resolveFromReferences = function (origin, references, root) {
+    var resolved = new Set();
+    for (var _i = 0, references_1 = references; _i < references_1.length; _i++) {
+        var reference = references_1[_i];
+        if (!reference.value.startsWith('.')) {
+            continue;
+        }
+        var target = resolveImportFile(origin, reference.value, root);
+        if (target) {
+            resolved.add(target);
+        }
+    }
+    return Array.from(resolved);
+};
+// DFS 搜索依赖图中是否存在一条从 start 回到 origin 的路径。
+// 通过节点数与深度上限，避免超大项目中搜索失控。
+var findPathToOrigin = function (start, origin, root) {
+    var nodesVisited = 0;
+    var visiting = new Set();
+    var deadEnds = new Set();
+    var walk = function (current, depth) {
+        if (depth > MAX_GRAPH_DEPTH) {
+            return null;
+        }
+        if (current === origin) {
+            return [origin];
+        }
+        if (deadEnds.has(current)) {
+            return null;
+        }
+        if (visiting.has(current)) {
+            return null;
+        }
+        nodesVisited += 1;
+        if (nodesVisited > MAX_GRAPH_NODES) {
+            return null;
+        }
+        visiting.add(current);
+        var neighbors = getResolvedImports(current, root);
+        for (var _i = 0, neighbors_1 = neighbors; _i < neighbors_1.length; _i++) {
+            var next = neighbors_1[_i];
+            var result = walk(next, depth + 1);
+            if (result) {
+                visiting.delete(current);
+                return __spreadArray([current], result, true);
+            }
+        }
+        visiting.delete(current);
+        deadEnds.add(current);
+        return null;
+    };
+    return walk(start, 0);
+};
+// 读取文件并通过简单正则抽取 import/require/export-from。
+// 这里不重新解析 AST，成本低但可能漏掉非常规写法。
+var getResolvedImports = function (filePath, root) {
+    var cached = resolvedImportCache.get(filePath);
+    if (cached) {
+        return cached;
+    }
+    var source = readFileSafe(filePath);
+    if (!source) {
+        resolvedImportCache.set(filePath, []);
+        return [];
+    }
+    var resolved = new Set();
+    var specifiers = extractImportSpecifiers(source);
+    for (var _i = 0, specifiers_1 = specifiers; _i < specifiers_1.length; _i++) {
+        var spec = specifiers_1[_i];
+        if (!spec.startsWith('.')) {
+            continue;
+        }
+        var target = resolveImportFile(filePath, spec, root);
+        if (target) {
+            resolved.add(target);
+        }
+    }
+    var list = Array.from(resolved);
+    resolvedImportCache.set(filePath, list);
+    return list;
+};
+var readFileSafe = function (filePath) {
+    try {
+        return fs_1.default.readFileSync(filePath, 'utf-8');
+    }
+    catch (_a) {
+        return null;
+    }
+};
+// 用正则匹配常见的导入写法，覆盖 import / dynamic import / require / export-from。
+var extractImportSpecifiers = function (source) {
+    var results = [];
+    var patterns = [
+        /import\s+(?:[^'"]+\s+from\s+)?['"]([^'"]+)['"]/g,
+        /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+        /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+        /export\s+[^'"]*from\s+['"]([^'"]+)['"]/g,
+    ];
+    for (var _i = 0, patterns_1 = patterns; _i < patterns_1.length; _i++) {
+        var pattern = patterns_1[_i];
+        var match = void 0;
+        while ((match = pattern.exec(source)) !== null) {
+            results.push(match[1]);
+        }
+    }
+    return results;
+};
+// 解析相对路径到真实文件：支持自动补全扩展名与目录 index。
+// 并确保解析结果在项目根目录内。
+var resolveImportFile = function (fromFile, specifier, root) {
+    if (!specifier.startsWith('.')) {
+        return null;
+    }
+    var cleaned = specifier.split(/[?#]/)[0];
+    var basePath = path_1.default.resolve(path_1.default.dirname(fromFile), cleaned);
+    var resolved = resolveFile(basePath) ||
+        resolveWithExtensions(basePath) ||
+        resolveFromDirectory(basePath);
+    if (!resolved) {
+        return null;
+    }
+    if (!isWithinRoot(resolved, root)) {
+        return null;
+    }
+    if (resolved.endsWith('.d.ts')) {
+        return null;
+    }
+    return resolved;
+};
+var resolveFile = function (candidate) {
+    if (!fs_1.default.existsSync(candidate)) {
+        return null;
+    }
+    try {
+        if (fs_1.default.statSync(candidate).isFile()) {
+            return candidate;
+        }
+    }
+    catch (_a) {
+        return null;
+    }
+    return null;
+};
+var resolveWithExtensions = function (basePath) {
+    var ext = path_1.default.extname(basePath);
+    if (ext && SUPPORTED_EXTENSIONS.includes(ext)) {
+        return resolveFile(basePath);
+    }
+    for (var _i = 0, SUPPORTED_EXTENSIONS_1 = SUPPORTED_EXTENSIONS; _i < SUPPORTED_EXTENSIONS_1.length; _i++) {
+        var extension = SUPPORTED_EXTENSIONS_1[_i];
+        var candidate = "".concat(basePath).concat(extension);
+        var resolved = resolveFile(candidate);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    return null;
+};
+var resolveFromDirectory = function (basePath) {
+    if (!fs_1.default.existsSync(basePath)) {
+        return null;
+    }
+    try {
+        if (!fs_1.default.statSync(basePath).isDirectory()) {
+            return null;
+        }
+    }
+    catch (_a) {
+        return null;
+    }
+    for (var _i = 0, SUPPORTED_EXTENSIONS_2 = SUPPORTED_EXTENSIONS; _i < SUPPORTED_EXTENSIONS_2.length; _i++) {
+        var extension = SUPPORTED_EXTENSIONS_2[_i];
+        var candidate = path_1.default.join(basePath, "index".concat(extension));
+        var resolved = resolveFile(candidate);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    return null;
+};
+// 将环路规范化为稳定 key，避免同一环路从不同入口重复报错。
+var buildCycleKey = function (cycle) {
+    if (cycle.length <= 2) {
+        return cycle.join('->');
+    }
+    var unique = cycle.slice(0, -1).map(function (entry) { return path_1.default.normalize(entry); });
+    var best = unique.join('->');
+    for (var index = 1; index < unique.length; index += 1) {
+        var rotated = unique.slice(index).concat(unique.slice(0, index));
+        var candidate = rotated.join('->');
+        if (candidate < best) {
+            best = candidate;
+        }
+    }
+    return best;
+};
+// 输出尽量相对路径，便于直接定位文件。
+var formatCycle = function (cycle, root) {
+    var formatted = cycle.map(function (entry) {
+        var relative = path_1.default.relative(root, entry);
+        if (!relative || relative.startsWith('..') || path_1.default.isAbsolute(relative)) {
+            return entry;
+        }
+        return relative;
+    });
+    return formatted.join(' -> ');
+};
+var buildLineIndex = function (source) {
+    var offsets = [0];
+    for (var index = 0; index < source.length; index += 1) {
+        if (source[index] === '\n') {
+            offsets.push(index + 1);
+        }
+    }
+    return { offsets: offsets };
+};
+var resolveLine = function (_a, position) {
+    var offsets = _a.offsets;
+    var low = 0;
+    var high = offsets.length - 1;
+    while (low <= high) {
+        var mid = Math.floor((low + high) / 2);
+        var current = offsets[mid];
+        if (current === position) {
+            return mid + 1;
+        }
+        if (current < position) {
+            low = mid + 1;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    return high + 1;
+};
+var readUtf8Character = function (source, index, code) {
+    if (code <= 0x7f) {
+        return { bytes: 1, nextIndex: index + 1 };
+    }
+    if (code <= 0x7ff) {
+        return { bytes: 2, nextIndex: index + 1 };
+    }
+    if (code >= 0xd800 && code <= 0xdbff && index + 1 < source.length) {
+        var next = source.charCodeAt(index + 1);
+        if (next >= 0xdc00 && next <= 0xdfff) {
+            return { bytes: 4, nextIndex: index + 2 };
+        }
+    }
+    return { bytes: 3, nextIndex: index + 1 };
+};
+var bytePosToCharIndex = function (source, moduleStart, bytePos) {
+    var target = Math.max(bytePos - moduleStart, 0);
+    if (target === 0) {
+        return 0;
+    }
+    var index = 0;
+    var byteOffset = 0;
+    while (index < source.length) {
+        var code = source.charCodeAt(index);
+        var _a = readUtf8Character(source, index, code), bytes = _a.bytes, nextIndex = _a.nextIndex;
+        if (byteOffset + bytes > target) {
+            return index;
+        }
+        byteOffset += bytes;
+        index = nextIndex;
+    }
+    return source.length;
+};
+var findImportLine = function (source, value) {
+    var lines = source.split(/\r?\n/);
+    for (var index = 0; index < lines.length; index += 1) {
+        var line = lines[index];
+        if (line.includes('import') && line.includes(value)) {
+            return index + 1;
+        }
+        if (line.includes('require') && line.includes(value)) {
+            return index + 1;
+        }
+    }
+    return undefined;
+};
+var selectLineNumber = function (computed, fallback) {
+    if (fallback === undefined) {
+        return computed;
+    }
+    if (computed === undefined) {
+        return fallback;
+    }
+    if (computed < fallback) {
+        return fallback;
+    }
+    return computed;
+};

package/dist/types/index.d.ts

@@ -3,4 +3,4 @@ export { RuleSeverity } from './types';
 export { defineRule, isRule, toRule } from './types';
 export { createRuleContext } from './runtime';
 export type { RuleContextOptions } from './runtime';
-export { builtinRules, noDeepRelativeImports, noSwallowedErrors } from './rules';
+export { builtinRules, noDeepRelativeImports, noCircularDependencies, noSwallowedErrors } from './rules';

package/dist/types/rules/index.d.ts

@@ -1,5 +1,6 @@
 import type { Rule } from '../types';
 import { noDeepRelativeImports } from './noDeepRelativeImports';
+import { noCircularDependencies } from './noCircularDependencies';
 import { noSwallowedErrors } from './noSwallowedErrors';
 export declare const builtinRules: Rule[];
-export { noDeepRelativeImports, noSwallowedErrors };
+export { noDeepRelativeImports, noCircularDependencies, noSwallowedErrors };

package/dist/types/rules/noCircularDependencies.d.ts

@@ -0,0 +1 @@
+export declare const noCircularDependencies: import("../types").Rule;

package/dist/types/types.d.ts

@@ -42,6 +42,9 @@ export interface RuleMessages {
         maxDepth: number;
     }): string;
     swallowedError(): string;
+    circularDependency(params: {
+        chain: string;
+    }): string;
 }
 export interface RuleHelpers {
     readonly imports: ReadonlyArray<ImportReference>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-cr-rules",
-  "version": "2.0.75",
+  "version": "2.0.78",
   "description": "Extensible static analysis rule set for the auto-cr automated code review toolkit",
   "main": "dist/index.js",
   "types": "dist/types/index.d.ts",
@@ -40,6 +40,7 @@
     "@swc/types": "^0.1.25"
   },
   "devDependencies": {
+    "@types/node": "^25.0.9",
     "tslib": "^2.8.1",
     "typescript": "^5.9.2"
   }