auto-cr-cmd 2.0.105 → 2.0.106

package/dist/report/index.js

@@ -56,7 +56,8 @@ function createReporter(filePath, source, options) {
         optimizing: 0,
     };
     var pushRecord = function (record) {
-        records.push(record);
+        var _a;
+        records.push(__assign(__assign({}, record), { filePath: (_a = record.filePath) !== null && _a !== void 0 ? _a : filePath }));
         totalViolations += 1;
         if (record.severity === auto_cr_rules_1.RuleSeverity.Error) {
             errorViolations += 1;
@@ -201,11 +202,12 @@ function renderCompactViolations(filePath, violations) {
     var indent = '  ';
     var bulletIndent = '    ';
     violations.forEach(function (violation) {
-        var _a, _b;
+        var _a, _b, _c;
         var severityLabel = (_a = SEVERITY_LABELS[violation.severity]) !== null && _a !== void 0 ? _a : 'error';
         var color = useColor ? (_b = SEVERITY_COLORS[violation.severity]) !== null && _b !== void 0 ? _b : '' : '';
         var reset = useColor ? RESET_COLOR : '';
-        var location = typeof violation.line === 'number' ? "".concat(filePath, ":").concat(violation.line) : "".concat(filePath, ":-");
+        var locationPath = (_c = violation.filePath) !== null && _c !== void 0 ? _c : filePath;
+        var location = typeof violation.line === 'number' ? "".concat(locationPath, ":").concat(violation.line) : "".concat(locationPath, ":-");
         var codeText = violation.code ? compactText(violation.code) : undefined;
         var message = stripRedundantCodeSuffix(compactText(violation.message), codeText);
         var header = "".concat(prefix).concat(color, "[").concat(severityLabel, "] ").concat(location, " ").concat(message).concat(reset);

package/dist/scan/analyzeFile.js

@@ -106,22 +106,23 @@ function analyzeFile(file, rules, format, log, createRuleContext, reporterHooks)
                                     helpers = __assign(__assign({}, sharedHelpers), { reportViolation: (function (input, span) {
                                             // 统一把规则输出收敛成结构化数据，避免各规则实现重复分支。
                                             var normalized = normalizeViolationInput(input, span);
+                                            var resolvedLine = resolveLineForViolation(baseContext.source, baseContext.sourceIndex, normalized);
                                             if (typeof reporterWithRecord_1.record === 'function') {
                                                 reporterWithRecord_1.record({
                                                     description: normalized.message,
                                                     code: normalized.code,
                                                     suggestions: normalized.suggestions,
                                                     span: normalized.span,
-                                                    line: normalized.line,
+                                                    line: resolvedLine,
                                                 });
                                                 return;
                                             }
-                                            if (normalized.span) {
-                                                scopedReporter_1.errorAtSpan(normalized.span, normalized.message);
+                                            if (resolvedLine !== undefined) {
+                                                scopedReporter_1.errorAtLine(resolvedLine, normalized.message);
                                                 return;
                                             }
-                                            if (typeof normalized.line === 'number') {
-                                                scopedReporter_1.errorAtLine(normalized.line, normalized.message);
+                                            if (normalized.span) {
+                                                scopedReporter_1.errorAtSpan(normalized.span, normalized.message);
                                                 return;
                                             }
                                             scopedReporter_1.error(normalized.message);
@@ -217,3 +218,78 @@ function normalizeViolationInput(input, spanArg) {
         span: spanArg,
     };
 }
+var resolveLineForViolation = function (source, sourceIndex, violation) {
+    if (typeof violation.line === 'number' && Number.isFinite(violation.line)) {
+        return violation.line;
+    }
+    var span = extractSpan(violation.span);
+    if (!span) {
+        return undefined;
+    }
+    var line = resolveLineFromByteOffset(source, sourceIndex, span.start);
+    return Number.isFinite(line) ? line : undefined;
+};
+var extractSpan = function (spanLike) {
+    if (!spanLike) {
+        return undefined;
+    }
+    if (typeof spanLike === 'object' && 'span' in spanLike) {
+        return spanLike.span;
+    }
+    return spanLike;
+};
+var resolveLineFromByteOffset = function (source, index, byteOffset) {
+    var charIndex = bytePosToCharIndex(source, index.moduleStart, byteOffset);
+    return resolveLine(index.lineOffsets, charIndex);
+};
+var resolveLine = function (lineOffsets, position) {
+    var low = 0;
+    var high = lineOffsets.length - 1;
+    while (low <= high) {
+        var mid = Math.floor((low + high) / 2);
+        var current = lineOffsets[mid];
+        if (current === position) {
+            return mid + 1;
+        }
+        if (current < position) {
+            low = mid + 1;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    return high + 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 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 };
+};

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

@@ -34,6 +34,7 @@ export interface ViolationRecord {
     tag: string;
     ruleName: string;
     severity: Severity;
+    filePath?: string;
     message: string;
     line?: number;
     code?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-cr-cmd",
-  "version": "2.0.105",
+  "version": "2.0.106",
   "description": "Fast automated code review CLI powered by SWC-based static analysis",
   "main": "./dist/index.js",
   "types": "./dist/types/index.d.ts",
@@ -39,7 +39,7 @@
     "consola": "^3.4.2",
     "jsonc-parser": "^3.3.1",
     "picomatch": "^4.0.3",
-    "auto-cr-rules": "2.0.105"
+    "auto-cr-rules": "2.0.106"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",