@codacy/tools-revive-1 0.3.0

package/dist/index.js

@@ -0,0 +1,1300 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_tooling2 = require("@codacy/tooling");
+
+// src/adapter.ts
+var import_tooling = require("@codacy/tooling");
+var import_path = __toESM(require("path"));
+var import_promises = __toESM(require("fs/promises"));
+
+// src/patterns.json
+var patterns_default = [
+  {
+    id: "Revive_add-constant",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Suggest Using Constants for Magic Numbers and String Literals",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_argument-limit",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Enforce Maximum Number of Function Parameters",
+    enabled: false,
+    parameters: [
+      {
+        name: "unnamedParam",
+        default: "4",
+        description: "(int) the maximum number of parameters allowed per function"
+      }
+    ]
+  },
+  {
+    id: "Revive_atomic",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid Common Mistakes with sync/atomic Package Usage",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_banned-characters",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Disallow Banned Characters in Identifiers",
+    enabled: false,
+    parameters: [
+      {
+        name: "unnamedParam",
+        default: "",
+        description: "comma-separated list of character to ban"
+      }
+    ]
+  },
+  {
+    id: "Revive_bare-return",
+    category: "Comprehensibility",
+    severityLevel: "Info",
+    title: "Avoid Bare Return Statements",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_blank-imports",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Enforce Proper Use of Blank Imports",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_bool-literal-in-expr",
+    category: "Comprehensibility",
+    severityLevel: "Info",
+    title: "Avoid Boolean Literals in Logic Expressions",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_call-to-gc",
+    category: "Performance",
+    severityLevel: "Warning",
+    title: "Avoid Explicit Calls to Garbage Collector",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_cognitive-complexity",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Enforce Maximum Cognitive Complexity",
+    enabled: false,
+    parameters: [
+      {
+        name: "unnamedParam",
+        default: "7",
+        description: "(int) the maximum function complexity"
+      }
+    ]
+  },
+  {
+    id: "Revive_comments-density",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Enforce Minimum Comments Density",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_comment-spacings",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Space After Comment Slashes",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_confusing-naming",
+    category: "Comprehensibility",
+    severityLevel: "Info",
+    title: "Avoid Confusing Naming Differing Only by Capitalization",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_confusing-results",
+    category: "ErrorProne",
+    severityLevel: "Warning",
+    title: "Avoid Returning Multiple Unnamed Values of the Same Type",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_constant-logical-expr",
+    category: "ErrorProne",
+    severityLevel: "Warning",
+    title: "Avoid Constant Logical Expressions",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_context-as-argument",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce context.Context as First Parameter",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_context-keys-type",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Using Basic Types as Keys in context.WithValue",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_cyclomatic",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Enforce Maximum Cyclomatic Complexity",
+    enabled: false,
+    parameters: [
+      {
+        name: "unnamedParam",
+        default: "3",
+        description: "(int) the maximum function complexity"
+      }
+    ]
+  },
+  {
+    id: "Revive_datarace",
+    category: "ErrorProne",
+    severityLevel: "Error",
+    title: "Avoid Data Races in Go Routines by Capturing Variables Correctly",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_deep-exit",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Exiting Program in Non-Main Functions",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_defer",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Warn on Common Mistakes Using defer Statement",
+    enabled: false,
+    parameters: [
+      {
+        name: "unnamedParam",
+        default: '"call-chain","loop"',
+        description: "(string) the unused params in functions"
+      }
+    ]
+  },
+  {
+    id: "Revive_dot-imports",
+    category: "Comprehensibility",
+    severityLevel: "Info",
+    title: "Avoid Dot Imports",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_duplicated-imports",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Duplicated Imports",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_early-return",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce Early Return to Minimize Nesting",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_empty-block",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Empty Blocks",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_empty-lines",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Heading or Trailing Empty Lines in Code Blocks",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_enforce-map-style",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Consistent Map Initialization Style",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_enforce-repeated-arg-type-style",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Consistent Repeated Argument and Return Value Type Style",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_enforce-slice-style",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Consistent Slice Initialization Style",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_enforce-switch-style",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce Consistent Default Case Usage in Switch Statements",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_errorf",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Simplify error creation by replacing errors.New(fmt.Sprintf()) with fmt.Errorf()",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_error-naming",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce error variable naming prefix",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_error-return",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Errors as Last Return Value",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_error-strings",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Error String Formatting",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_exported",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "EnforceCommentsOnExportedFunctionsAndMethods",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_file-header",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce File Header Presence",
+    enabled: false,
+    parameters: [
+      {
+        name: "unnamedParam",
+        default: "",
+        description: "(string) the header to look for in source files"
+      }
+    ]
+  },
+  {
+    id: "Revive_file-length-limit",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Enforce File Length Limit",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_filename-format",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Filename Format",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_flag-parameter",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Flag Parameters",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_function-length",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Enforce Function Length Limits",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_function-result-limit",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Limit Number of Return Values in Functions",
+    enabled: false,
+    parameters: [
+      {
+        name: "unnamedParam",
+        default: "3",
+        description: "(int) the maximum allowed return values"
+      }
+    ]
+  },
+  {
+    id: "Revive_get-return",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Enforce Functions Prefixed with 'Get' to Return a Value",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_identical-branches",
+    category: "ErrorProne",
+    severityLevel: "Warning",
+    title: "Avoid Identical Branches in If-Then-Else Conditionals",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_identical-ifelseif-branches",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid identical if/else-if branches",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_identical-ifelseif-conditions",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid identical if/else-if conditions",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_identical-switch-branches",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid identical switch branches",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_identical-switch-conditions",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid identical switch case conditions",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_if-return",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Redundant if-Error Return",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_import-alias-naming",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Import Alias Naming Conventions",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_imports-blocklist",
+    category: "Security",
+    severityLevel: "High",
+    title: "Warn on Importing Block-Listed Packages",
+    enabled: false,
+    parameters: [
+      {
+        name: "unnamedParam",
+        default: '"crypto/md5", "crypto/sha1"',
+        description: "(list of string) block-list of package names (or regular expression package names)"
+      }
+    ]
+  },
+  {
+    id: "Revive_import-shadowing",
+    category: "ErrorProne",
+    severityLevel: "Warning",
+    title: "Avoid Import Shadowing",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_increment-decrement",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce use of increment and decrement operators",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_indent-error-flow",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Redundant Else Blocks to Reduce Indentation",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_line-length-limit",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Maximum Line Length",
+    enabled: false,
+    parameters: [
+      {
+        name: "unnamedParam",
+        default: "80",
+        description: "(int) maximum line length in characters"
+      }
+    ]
+  },
+  {
+    id: "Revive_max-control-nesting",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Enforce Maximum Control Structure Nesting",
+    enabled: false,
+    parameters: [
+      {
+        name: "unnamedParam",
+        default: "5",
+        description: "(int) maximum accepted nesting level of control structures"
+      }
+    ]
+  },
+  {
+    id: "Revive_max-public-structs",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Limit Number of Public Structs",
+    enabled: false,
+    parameters: [
+      {
+        name: "unnamedParam",
+        default: "5",
+        description: "(int) the maximum allowed public structs"
+      }
+    ]
+  },
+  {
+    id: "Revive_modifies-parameter",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Modifying Function Parameters",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_modifies-value-receiver",
+    category: "ErrorProne",
+    severityLevel: "Warning",
+    title: "Avoid Modifying Value Receiver",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_nested-structs",
+    category: "Comprehensibility",
+    severityLevel: "Info",
+    title: "Avoid Nested Structs",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_optimize-operands-order",
+    category: "Performance",
+    severityLevel: "Warning",
+    title: "Optimize Operands Order in Conditional Expressions",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_package-comments",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Enforce Package Comments",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_package-directory-mismatch",
+    category: "Comprehensibility",
+    severityLevel: "Info",
+    title: "Enforce package name matches directory",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_range",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid Using Address of Range Variables in Loops",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_range-val-address",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid Taking Address of Range Variables",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_range-val-in-closure",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid range variable reuse in closure",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_receiver-naming",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Receiver Naming Convention",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_redefines-builtin-id",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid Redefining Built-in Identifiers",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_redundant-build-tag",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Redundant Build Tag Comments",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_redundant-import-alias",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Redundant Import Aliases",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_redundant-test-main-exit",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Avoid Redundant Exit Calls in TestMain",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_string-format",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Enforce String Literal Format in Specific Function Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_string-of-int",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid Suspicious String Conversion of Integers",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_struct-tag",
+    category: "ErrorProne",
+    severityLevel: "Warning",
+    title: "Check Struct Tags",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_superfluous-else",
+    category: "Comprehensibility",
+    severityLevel: "Info",
+    title: "Avoid Superfluous Else Blocks",
+    enabled: true,
+    parameters: [
+      {
+        name: "unnamedParam",
+        default: "",
+        description: '(list of string) the flags ("preserveScope")'
+      }
+    ]
+  },
+  {
+    id: "Revive_time-date",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid bad usage of time.Date",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_time-equal",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid Using == and != for Comparing time.Time Values",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_time-naming",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Unit-Specific Suffixes in time.Duration Variable Names",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_unchecked-type-assertion",
+    category: "ErrorProne",
+    severityLevel: "Error",
+    title: "Enforce Checked Type Assertions",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_unconditional-recursion",
+    category: "ErrorProne",
+    severityLevel: "Error",
+    title: "Avoid Unconditional Recursion",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_unexported-naming",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce unexported symbol naming convention",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_unexported-return",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Exported Functions Returning Unexported Types",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_unhandled-error",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Enforce Explicit Handling of Returned Errors",
+    enabled: false,
+    parameters: [
+      {
+        name: "unnamedParam",
+        default: '"fmt.Printf"',
+        description: "(list of string) function names regexp patterns to ignore"
+      }
+    ]
+  },
+  {
+    id: "Revive_unnecessary-format",
+    category: "Performance",
+    severityLevel: "Warning",
+    title: "Avoid Unnecessary Formatting Function Calls",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_unnecessary-stmt",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Remove Unnecessary Statements",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_unreachable-code",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Remove Unreachable Code",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_unsecure-url-scheme",
+    category: "Security",
+    severityLevel: "High",
+    title: "Avoid unsecure URL schemes",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_unused-parameter",
+    category: "UnusedCode",
+    severityLevel: "Warning",
+    title: "Avoid Unused Parameters",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_unused-receiver",
+    category: "ErrorProne",
+    severityLevel: "Warning",
+    title: "Avoid Unused Method Receivers",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_use-any",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Replace interface{} with any",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_use-errors-new",
+    category: "Performance",
+    severityLevel: "Warning",
+    title: "Use errors.New Instead of fmt.Errorf When No Formatting Is Needed",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_use-fmt-print",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce use of fmt.Print instead of built-in print/println",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_useless-break",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Useless Break Statements in Case Clauses",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_useless-fallthrough",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid useless fallthrough",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_use-waitgroup-go",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Use WaitGroup.Go",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "Revive_var-declaration",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Simplified Variable Declarations",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_var-naming",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Variable and Package Naming Conventions",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "Revive_waitgroup-by-value",
+    category: "ErrorProne",
+    severityLevel: "High",
+    title: "Avoid Passing sync.WaitGroup by Value",
+    enabled: false,
+    parameters: []
+  }
+];
+
+// src/adapter.ts
+var TOOL_ID = "Revive";
+var VALID_CATEGORIES = /* @__PURE__ */ new Set([
+  "Security",
+  "ErrorProne",
+  "CodeStyle",
+  "Compatibility",
+  "Performance",
+  "UnusedCode",
+  "Complexity",
+  "BestPractice",
+  "Documentation"
+]);
+var PATTERN_META = new Map(
+  patterns_default.map((p) => [
+    p.id,
+    {
+      category: VALID_CATEGORIES.has(p.category) ? p.category : "BestPractice",
+      severity: p.severityLevel ?? "Info"
+    }
+  ])
+);
+function ruleMetadata(ruleName) {
+  const patternId = `${TOOL_ID}_${ruleName}`;
+  return PATTERN_META.get(patternId) ?? { category: "BestPractice", severity: "Info" };
+}
+function getLineContent(lines, lineNumber) {
+  return lines[lineNumber - 1] ?? "";
+}
+async function readFileLines(filePath) {
+  try {
+    const content = await import_promises.default.readFile(filePath, "utf-8");
+    return content.split("\n");
+  } catch {
+    return [];
+  }
+}
+function buildResult(startedAt, completedAt, issues, errors, filesAnalyzed) {
+  const durationMs = completedAt.getTime() - startedAt.getTime();
+  return {
+    metadata: {
+      startedAt: startedAt.toISOString(),
+      completedAt: completedAt.toISOString(),
+      durationMs
+    },
+    issues,
+    errors,
+    summary: {
+      toolId: TOOL_ID,
+      status: errors.some((e) => e.level === "error") ? "partial" : "success",
+      issueCount: issues.length,
+      errorCount: errors.length,
+      durationMs,
+      filesAnalyzed
+    }
+  };
+}
+var BINARY = "revive";
+var PLATFORM_MAP = {
+  "darwin-arm64": "darwin_arm64",
+  "darwin-x64": "darwin_amd64",
+  "linux-x64": "linux_amd64",
+  "linux-arm64": "linux_arm64"
+};
+async function getVersionFromBinary(binaryPath) {
+  try {
+    const { stdout, exitCode } = await (0, import_tooling.spawnTool)(binaryPath, ["-version"], {
+      cwd: process.cwd()
+    });
+    if (exitCode !== 0) return null;
+    const match = stdout.match(/(\d+\.\d+\.\d+)/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveBinaryPath(ctx) {
+  const codacyBin = import_path.default.join(ctx.toolInstallDir, BINARY);
+  const version = await getVersionFromBinary(codacyBin);
+  if (version) return codacyBin;
+  return BINARY;
+}
+function generateReviveToml(patterns) {
+  const lines = [];
+  lines.push("confidence = 0.0");
+  lines.push("");
+  for (const pattern of patterns) {
+    const ruleName = pattern.patternId.replace(`${TOOL_ID}_`, "");
+    lines.push(`[rule.${ruleName}]`);
+    if (pattern.parameters && pattern.parameters.length > 0) {
+      const args = pattern.parameters.map((p) => {
+        const num = Number(p.value);
+        if (!isNaN(num) && String(p.value).trim() !== "") {
+          return String(num);
+        }
+        return `"${String(p.value)}"`;
+      });
+      lines.push(`  arguments = [${args.join(", ")}]`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+var adapter = {
+  id: TOOL_ID,
+  displayName: "Revive",
+  preferredVersion: "1.12.0",
+  compatibleVersions: ">=1.0.0",
+  website: "https://github.com/mgechev/revive",
+  languages: ["Go"],
+  filePatterns: ["**/*.go"],
+  supportedOS: ["linux", "darwin"],
+  supportedArch: ["x64", "arm64"],
+  supportedRunners: ["local", "container"],
+  prerequisites: [],
+  /**
+   * Checks whether the `revive` binary is present and runnable.
+   *
+   * Checks in order:
+   * 1. Codacy-managed path (`ctx.toolInstallDir/revive`) -> installation: "codacy"
+   * 2. Global PATH (`revive`) -> installation: "global"
+   *
+   * Also probes for Go runtime availability via findGo(), reporting it as a
+   * dependency. Go is needed for type-checked rules but revive can still run
+   * basic rules without it.
+   */
+  async checkAvailability(ctx) {
+    ctx.logger.debug("Checking availability", { toolId: TOOL_ID });
+    const goInfo = await (0, import_tooling.findGo)(">=1.21", ctx.logger);
+    const goDep = goInfo ? { name: "go", version: goInfo.version, path: goInfo.path, available: true } : { name: "go", available: false, reason: "Go not found; type-checked rules may not work" };
+    const codacyBin = import_path.default.join(ctx.toolInstallDir, BINARY);
+    const codacyVersion = await getVersionFromBinary(codacyBin);
+    if (codacyVersion) {
+      ctx.logger.debug("Found codacy-managed binary", {
+        toolId: TOOL_ID,
+        version: codacyVersion,
+        path: codacyBin
+      });
+      return {
+        available: true,
+        version: codacyVersion,
+        path: codacyBin,
+        installation: "codacy",
+        dependencies: [goDep]
+      };
+    }
+    const globalVersion = await getVersionFromBinary(BINARY);
+    if (globalVersion) {
+      ctx.logger.debug("Found global binary", { toolId: TOOL_ID, version: globalVersion });
+      return {
+        available: true,
+        version: globalVersion,
+        installation: "global",
+        dependencies: [goDep]
+      };
+    }
+    ctx.logger.debug("Binary not found", {
+      toolId: TOOL_ID,
+      reason: "not in PATH or Codacy install directory"
+    });
+    return {
+      available: false,
+      reason: "revive binary not found in PATH or Codacy install directory",
+      installHint: "go install github.com/mgechev/revive@latest   # install via Go\ncodacy-analysis analyze . --install-dependencies  # auto-install"
+    };
+  },
+  /**
+   * Downloads the revive binary from GitHub releases and ensures the Go
+   * toolchain is available for type-checked analysis rules.
+   *
+   * 1. Downloads the pre-built revive binary (tar.gz) and extracts it.
+   * 2. Downloads the Go SDK via ensureGo() if not already present.
+   */
+  async install(ctx) {
+    ctx.logger.info("Starting install", { toolId: TOOL_ID });
+    const platformKey = `${ctx.platform.os}-${ctx.platform.arch}`;
+    const platformSuffix = PLATFORM_MAP[platformKey];
+    if (!platformSuffix) {
+      return {
+        success: false,
+        error: {
+          toolId: TOOL_ID,
+          phase: "toolInstall",
+          kind: "UnsupportedPlatform",
+          message: `Unsupported platform: ${platformKey}. Supported: ${Object.keys(PLATFORM_MAP).join(", ")}`,
+          level: "error"
+        }
+      };
+    }
+    const version = adapter.preferredVersion;
+    const url = `https://github.com/mgechev/revive/releases/download/v${version}/revive_${platformSuffix}.tar.gz`;
+    const destDir = ctx.toolInstallDir;
+    try {
+      ctx.logger.info(`Downloading revive v${version} for ${platformKey}...`);
+      await import_promises.default.mkdir(destDir, { recursive: true });
+      await (0, import_tooling.downloadAndExtract)(url, destDir, void 0, ctx.logger);
+      const destPath = import_path.default.join(destDir, BINARY);
+      await import_promises.default.chmod(destPath, 493);
+      ctx.logger.info(`Installed revive v${version} to ${destPath}`);
+    } catch (err) {
+      return {
+        success: false,
+        error: {
+          toolId: TOOL_ID,
+          phase: "toolInstall",
+          kind: "DownloadError",
+          message: `Failed to download revive: ${err instanceof Error ? err.message : String(err)}`,
+          level: "error"
+        }
+      };
+    }
+    try {
+      const goInfo = await (0, import_tooling.ensureGo)(ctx.globalDir, ">=1.21", ctx.logger);
+      if (goInfo) {
+        ctx.logger.info(`Go toolchain ready: v${goInfo.version} at ${goInfo.path}`);
+      } else {
+        ctx.logger.warn("Could not obtain Go toolchain; type-checked rules may not work");
+      }
+    } catch (err) {
+      ctx.logger.warn(
+        `Failed to set up Go toolchain: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    return {
+      success: true,
+      installedPath: import_path.default.join(destDir, BINARY),
+      installedVersion: version
+    };
+  },
+  /**
+   * Checks for `revive.toml` in the repository root.
+   *
+   * Revive uses TOML configuration files. The conventional name is `revive.toml`.
+   */
+  async checkLocalConfigurationFile(ctx) {
+    ctx.logger.debug("Checking for local config", { toolId: TOOL_ID });
+    const candidate = import_path.default.join(ctx.repositoryRoot, "revive.toml");
+    try {
+      await import_promises.default.access(candidate);
+      ctx.logger.debug("Local config found", { toolId: TOOL_ID, path: candidate });
+      return { found: true, path: candidate };
+    } catch {
+    }
+    return { found: false };
+  },
+  /**
+   * Runs `revive -formatter json -set_exit_status` against Go source files
+   * and converts the JSON output into Codacy Issue objects.
+   *
+   * Config resolution:
+   * - If `useLocalConfigurationFile` is true and `localConfigurationFile` is
+   *   set, passes `-config <path>` to revive.
+   * - If patterns are provided (but no local config), generates a TOML config
+   *   enabling exactly those rules and passes it via `-config`.
+   * - If no patterns and no local config, skips execution.
+   *
+   * Before running revive, if the project has a go.mod, runs `go mod download`
+   * to fetch dependencies needed for type-checked analysis.
+   *
+   * Exit codes:
+   * - 0: success, no issues found
+   * - 1: success, issues found (normal — not treated as an error)
+   *
+   * Never throws — all errors are captured in the returned `errors` array.
+   */
+  async analyze(ctx, codacyConfig) {
+    const startMs = Date.now();
+    ctx.logger.info("Starting analysis", { toolId: TOOL_ID, fileCount: ctx.targetFiles.length });
+    const startedAt = /* @__PURE__ */ new Date();
+    const issues = [];
+    const errors = [];
+    if (ctx.targetFiles.length === 0) {
+      return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, 0);
+    }
+    let configPath;
+    if (codacyConfig.useLocalConfigurationFile && codacyConfig.localConfigurationFile) {
+      configPath = codacyConfig.localConfigurationFile;
+    } else if (codacyConfig.patterns.length > 0) {
+      const tomlContent = generateReviveToml(codacyConfig.patterns);
+      await import_promises.default.mkdir(ctx.generatedConfigDir, { recursive: true });
+      configPath = import_path.default.join(ctx.generatedConfigDir, "revive.toml");
+      await import_promises.default.writeFile(configPath, tomlContent, "utf-8");
+      ctx.logger.debug("Generated revive config", { path: configPath });
+    } else {
+      ctx.logger.info("Skipping analysis: no local config and no patterns enabled", {
+        toolId: TOOL_ID
+      });
+      return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+    }
+    const binary = await resolveBinaryPath(ctx);
+    const goInfo = await (0, import_tooling.findGo)(">=1.21", ctx.logger);
+    let goEnv;
+    if (goInfo) {
+      goEnv = (0, import_tooling.buildGoEnv)(goInfo, ctx.globalDir);
+      await (0, import_tooling.goModDownload)(goInfo, ctx.repositoryRoot, goEnv, ctx.logger);
+    } else {
+      ctx.logger.debug("Go not available; type-checked rules may produce errors");
+    }
+    const absoluteFiles = ctx.targetFiles.map((f) => import_path.default.resolve(ctx.repositoryRoot, f));
+    const args = ["-formatter", "json", "-set_exit_status"];
+    if (configPath) {
+      args.push("-config", configPath);
+    }
+    args.push(...absoluteFiles);
+    try {
+      const spawnOpts = {
+        cwd: ctx.repositoryRoot,
+        logger: ctx.logger
+      };
+      if (goEnv) {
+        spawnOpts.env = goEnv;
+      }
+      const { stdout, stderr, exitCode } = await (0, import_tooling.spawnTool)(binary, args, spawnOpts);
+      if (exitCode >= 2) {
+        errors.push({
+          toolId: TOOL_ID,
+          phase: "toolInvoke",
+          kind: "NonZeroExit",
+          message: `revive exited with code ${exitCode}${stderr ? `: ${stderr.trim()}` : ""}`,
+          level: "error"
+        });
+        return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+      }
+      if (!stdout.trim()) {
+        return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+      }
+      let findings;
+      try {
+        findings = JSON.parse(stdout);
+      } catch (err) {
+        errors.push({
+          toolId: TOOL_ID,
+          phase: "outputParse",
+          kind: "MalformedOutput",
+          message: `Failed to parse revive JSON output: ${err instanceof Error ? err.message : String(err)}`,
+          level: "error"
+        });
+        return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+      }
+      const enabledPatterns = new Set(codacyConfig.patterns.map((p) => p.patternId));
+      const findingsByFile = /* @__PURE__ */ new Map();
+      for (const finding of findings) {
+        const filePath = finding.Position.Start.Filename;
+        const list = findingsByFile.get(filePath) ?? [];
+        list.push(finding);
+        findingsByFile.set(filePath, list);
+      }
+      for (const [filePath, fileFindings] of findingsByFile) {
+        const absoluteFilePath = import_path.default.isAbsolute(filePath) ? filePath : import_path.default.resolve(ctx.repositoryRoot, filePath);
+        const lines = await readFileLines(absoluteFilePath);
+        const relPath = import_path.default.isAbsolute(filePath) ? import_path.default.relative(ctx.repositoryRoot, filePath) : filePath;
+        for (const finding of fileFindings) {
+          const patternId = `${TOOL_ID}_${finding.RuleName}`;
+          if (enabledPatterns.size > 0 && !enabledPatterns.has(patternId)) {
+            continue;
+          }
+          const meta = ruleMetadata(finding.RuleName);
+          const line = Math.max(finding.Position.Start.Line, 1);
+          const column = Math.max(finding.Position.Start.Column, 1);
+          const endLine = finding.Position.End.Line > 0 ? finding.Position.End.Line : void 0;
+          const endColumn = finding.Position.End.Column > 0 ? finding.Position.End.Column : void 0;
+          issues.push({
+            filePath: relPath,
+            patternId,
+            toolId: TOOL_ID,
+            line,
+            column,
+            endLine,
+            endColumn,
+            message: finding.Failure,
+            lineContent: getLineContent(lines, line),
+            multilineContent: (0, import_tooling.getMultilineContent)(lines, line, endLine),
+            category: meta.category,
+            severity: meta.severity
+          });
+        }
+      }
+      if (stderr.trim()) {
+        errors.push({
+          toolId: TOOL_ID,
+          phase: "outputParse",
+          kind: "ParseWarning",
+          message: `revive stderr: ${stderr.trim()}`,
+          level: "warning"
+        });
+      }
+    } catch (err) {
+      errors.push({
+        toolId: TOOL_ID,
+        phase: "toolInvoke",
+        kind: "InvocationError",
+        message: `Failed to run revive: ${err instanceof Error ? err.message : String(err)}`,
+        level: "error"
+      });
+    }
+    const durationMs = Date.now() - startMs;
+    ctx.logger.info("Analysis complete", {
+      toolId: TOOL_ID,
+      issueCount: issues.length,
+      errorCount: errors.length,
+      durationMs
+    });
+    return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+  }
+};
+
+// src/index.ts
+var index_default = (0, import_tooling2.defineToolAdapter)(adapter);