@codacy/tools-reek-6 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Codacy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,69 @@
+# @codacy/tools-reek-6
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Updating patterns](#updating-patterns)
+- [Updating the Reek version](#updating-the-reek-version)
+- [Development](#development)
+- [Notes for maintainers](#notes-for-maintainers)
+
+---
+
+## Overview
+
+Ruby code smell detector using the [Reek](https://github.com/troessner/reek) gem. Uses the CLI execution strategy -- spawns `reek --format json` via `spawnTool()` and parses its JSON output.
+
+| Property      | Value                                  |
+| ------------- | -------------------------------------- |
+| Tool ID       | `Reek`                                 |
+| Codacy UUID   | `ec8f6265-18e8-478a-a295-7a4c09fa2171` |
+| Strategy      | CLI                                    |
+| Languages     | Ruby                                   |
+| Binary        | `reek` (installed via `gem install`)   |
+| File patterns | `**/*.rb`                              |
+
+## Updating patterns
+
+```bash
+# Re-fetch pattern metadata from the Codacy API
+pnpm prefetch
+
+# Commit the result
+git add src/patterns.json
+```
+
+The `prefetch` script calls `packages/tools/scripts/fetch-patterns.mjs` with the tool UUID to download pattern metadata (IDs, categories, severity levels) from the Codacy API.
+
+Pattern IDs are bare smell type names (no prefix): `FeatureEnvy`, `TooManyStatements`, `UncommunicativeMethodName`, etc.
+
+## Updating the Reek version
+
+1. Update `REEK_VERSION` in `src/adapter.ts`
+2. Run `pnpm prefetch` to check for new/removed smells
+3. Run `pnpm test` to verify compatibility
+4. If the major version changes, create a new adapter package (`reek-7/`)
+
+## Development
+
+```bash
+pnpm build    # Build with tsup
+pnpm test     # Run tests (requires ruby + reek in PATH for integration tests)
+```
+
+To install reek locally for testing:
+
+```bash
+gem install reek -v 6.5.0
+```
+
+## Notes for maintainers
+
+- Reek requires Ruby >= 2.7 as a runtime. The adapter uses `ensureRuby()` to download a portable Ruby if no system Ruby is found.
+- Gems are installed in an isolated directory at `~/.codacy/runtimes/reek-6/gems/` via `GEM_HOME`/`GEM_PATH` environment variables.
+- Output format is a flat JSON array of smell objects, each with `smell_type`, `source`, `lines[]`, `message`, and `context`.
+- The `lines` field is an array -- a single smell can span multiple lines. The adapter uses `lines[0]` as the primary line number.
+- Exit codes: 0 = no smells, 2 = smells found (both success), 1 = runtime error.
+- Pattern IDs in `patterns.json` have no prefix -- they are bare smell type names matching `smell_type` from Reek's JSON output.
+- Pattern filtering is post-hoc: Reek runs against all provided files, then output is filtered by the enabled patterns set.
+- Config file detection supports `.reek.yml` and `config.reek`. When a local config is found and `useLocalConfigurationFile` is true, it is passed via `--config <path>`.

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import * as _codacy_tooling from '@codacy/tooling';
+
+declare const _default: Readonly<_codacy_tooling.ToolAdapter>;
+
+export { _default as default };

package/dist/index.js

@@ -0,0 +1,883 @@
+"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: "Attribute",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Public Writable Attributes",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      }
+    ]
+  },
+  {
+    id: "BooleanParameter",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Avoid Boolean Parameter",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      }
+    ]
+  },
+  {
+    id: "ClassVariable",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Class Variables",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      }
+    ]
+  },
+  {
+    id: "ControlParameter",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Avoid Control Parameter",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      }
+    ]
+  },
+  {
+    id: "DataClump",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Detect Data Clumps in Method Parameters",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      },
+      {
+        name: "max_copies",
+        default: "2",
+        description: "The maximum number of methods that are permitted to take the same group of parameters. Defaults to 2."
+      },
+      {
+        name: "min_clump_size",
+        default: "2",
+        description: "The smallest number of parameters that can be reported as a clump. Defaults to 2."
+      }
+    ]
+  },
+  {
+    id: "DuplicateMethodCall",
+    category: "Performance",
+    severityLevel: "Warning",
+    title: "Avoid Duplicate Method Calls Within a Method",
+    enabled: false,
+    parameters: [
+      {
+        name: "allow_calls",
+        default: "[]",
+        description: "Ignores any context who matches it."
+      },
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      },
+      {
+        name: "max_calls",
+        default: "1",
+        description: "The maximum number of duplicate calls allowed within a method. Defaults to 1."
+      }
+    ]
+  },
+  {
+    id: "FeatureEnvy",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Detect Feature Envy",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      }
+    ]
+  },
+  {
+    id: "InstanceVariableAssumption",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Instance Variable Assumption",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      }
+    ]
+  },
+  {
+    id: "IrresponsibleModule",
+    category: "Documentation",
+    severityLevel: "Info",
+    title: "Enforce Descriptive Comments on Modules and Classes",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      }
+    ]
+  },
+  {
+    id: "LongYieldList",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Avoid Long Yield List",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      },
+      {
+        name: "max_params",
+        default: "3",
+        description: "The maximum number of parameters allowed in a method or block before a warning is issued. Defaults to 3."
+      }
+    ]
+  },
+  {
+    id: "ManualDispatch",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Manual Dispatch",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      }
+    ]
+  },
+  {
+    id: "MissingSafeMethod",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Detect Missing Safe Method",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      }
+    ]
+  },
+  {
+    id: "ModuleInitialize",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid defining initialize method in modules",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      }
+    ]
+  },
+  {
+    id: "NestedIterators",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Avoid Nested Iterators",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      },
+      {
+        name: "ignore_iterators",
+        default: "[]",
+        description: "List of iterators to be excluded from the smell check. Includes only tap at the moment"
+      },
+      {
+        name: "max_allowed_nesting",
+        default: "1",
+        description: "The maximum depth of nested iterators. Defaults to 1"
+      }
+    ]
+  },
+  {
+    id: "NilCheck",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Nil Checks",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      }
+    ]
+  },
+  {
+    id: "RepeatedConditional",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Avoid Repeated Conditional",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      },
+      {
+        name: "max_ifs",
+        default: "2",
+        description: "The maximum number of identical conditional tests permitted before Reek raises a warning. Defaults to 2."
+      }
+    ]
+  },
+  {
+    id: "SubclassedFromCoreClass",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Subclassing Core Classes",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      }
+    ]
+  },
+  {
+    id: "TooManyConstants",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Avoid Too Many Constants in a Class",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      },
+      {
+        name: "max_constants",
+        default: "5",
+        description: "The maximum number of constants that are permitted. Defaults to 5"
+      }
+    ]
+  },
+  {
+    id: "TooManyInstanceVariables",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Avoid Too Many Instance Variables",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      },
+      {
+        name: "max_instance_variables",
+        default: "4",
+        description: "The maximum number of instance variables that are permitted. Defaults to 4"
+      }
+    ]
+  },
+  {
+    id: "TooManyMethods",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Detect Too Many Methods in Class",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      },
+      {
+        name: "max_methods",
+        default: "15",
+        description: "The maximum number of methods that are permitted. Defaults to 15"
+      }
+    ]
+  },
+  {
+    id: "TooManyStatements",
+    category: "Complexity",
+    severityLevel: "Warning",
+    title: "Avoid Methods with Too Many Statements",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      },
+      {
+        name: "max_statements",
+        default: "5",
+        description: "The maximum number of statements allowed in a method before a warning is issued. Defaults to 5."
+      }
+    ]
+  },
+  {
+    id: "UncommunicativeMethodName",
+    category: "Comprehensibility",
+    severityLevel: "Warning",
+    title: "Avoid Uncommunicative Method Names",
+    enabled: false,
+    parameters: [
+      {
+        name: "accept",
+        default: "[]",
+        description: "The set of names that Reek will accept (and not report) even if they match one of the reject expressions."
+      },
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      }
+    ]
+  },
+  {
+    id: "UncommunicativeModuleName",
+    category: "Comprehensibility",
+    severityLevel: "Info",
+    title: "Avoid Uncommunicative Module Names",
+    enabled: false,
+    parameters: [
+      {
+        name: "accept",
+        default: "[]",
+        description: "The set of names that Reek will accept (and not report) even if they match one of the reject expressions. Empty by default."
+      },
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      }
+    ]
+  },
+  {
+    id: "UncommunicativeParameterName",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Uncommunicative Parameter Names",
+    enabled: false,
+    parameters: [
+      {
+        name: "accept",
+        default: "[]",
+        description: "The set of names that Reek will accept (and not report) even if they match one of the reject expressions."
+      },
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      }
+    ]
+  },
+  {
+    id: "UncommunicativeVariableName",
+    category: "Comprehensibility",
+    severityLevel: "Info",
+    title: "Avoid Uncommunicative Variable Names",
+    enabled: false,
+    parameters: [
+      {
+        name: "accept",
+        default: '["_"]',
+        description: "Names that will be accepted (not reported) even if they match one of the reject expressions. Defaults to _."
+      },
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      }
+    ]
+  },
+  {
+    id: "UnusedParameters",
+    category: "UnusedCode",
+    severityLevel: "Warning",
+    title: "Avoid Unused Parameters in Methods",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      }
+    ]
+  },
+  {
+    id: "UnusedPrivateMethod",
+    category: "UnusedCode",
+    severityLevel: "Warning",
+    title: "Avoid Unused Private Methods",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      }
+    ]
+  },
+  {
+    id: "UtilityFunction",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Detect Utility Functions",
+    enabled: true,
+    parameters: [
+      {
+        name: "exclude",
+        default: "[]",
+        description: "Ignores any context whose full description matches any element of this array."
+      },
+      {
+        name: "public_methods_only",
+        default: "false",
+        description: "Disable this smell detector for non-public methods (which means 'private' and 'protected')"
+      }
+    ]
+  }
+];
+
+// src/adapter.ts
+var TOOL_ID = "Reek";
+var ADAPTER_ID = "reek-6";
+var REEK_VERSION = "6.5.0";
+var RUBY_VERSION_RANGE = ">=2.7.0";
+var CONFIG_FILE_CANDIDATES = [".reek.yml", "config.reek"];
+var PATTERN_META = new Map(
+  patterns_default.map((p) => [
+    p.id,
+    {
+      category: p.category,
+      severity: p.severityLevel ?? "Info"
+    }
+  ])
+);
+function ruleMetadata(smellType) {
+  return PATTERN_META.get(smellType) ?? { category: "CodeStyle", 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
+    }
+  };
+}
+async function resolveToolInvocation(ctx) {
+  const gemPaths = (0, import_tooling.getGemPaths)(ctx.globalDir, ADAPTER_ID);
+  const scriptPath = (0, import_tooling.resolveGemBinary)(gemPaths, "reek");
+  const portableRubyBin = (0, import_tooling.resolvePortableRubyBinary)(ctx.globalDir, "3.2.11");
+  try {
+    await import_promises.default.access(portableRubyBin);
+    await import_promises.default.access(scriptPath);
+    return { binary: portableRubyBin, prefixArgs: [scriptPath], rubyPath: portableRubyBin };
+  } catch {
+  }
+  const rubyInfo = await (0, import_tooling.findRuby)(RUBY_VERSION_RANGE).catch(() => null);
+  try {
+    await import_promises.default.access(scriptPath);
+    return {
+      binary: scriptPath,
+      prefixArgs: [],
+      rubyPath: rubyInfo?.path
+    };
+  } catch {
+  }
+  return { binary: "reek", prefixArgs: [], rubyPath: rubyInfo?.path };
+}
+var adapter = {
+  id: TOOL_ID,
+  displayName: "Reek",
+  preferredVersion: REEK_VERSION,
+  compatibleVersions: ">=6.0.0",
+  website: "https://github.com/troessner/reek",
+  languages: ["Ruby"],
+  filePatterns: ["**/*.rb"],
+  supportedOS: ["linux", "darwin", "win32"],
+  supportedArch: ["x64", "arm64"],
+  supportedRunners: ["local", "container"],
+  prerequisites: [
+    {
+      name: "Ruby",
+      versionRange: RUBY_VERSION_RANGE,
+      preferredVersion: "3.2",
+      checkCommand: "ruby --version"
+    }
+  ],
+  /**
+   * Checks whether Reek is available (Ruby runtime + reek gem).
+   *
+   * Checks:
+   * 1. Ruby runtime via findRuby
+   * 2. Reek binary in the Codacy-managed gem directory or on PATH
+   */
+  async checkAvailability(ctx) {
+    ctx.logger.debug("Checking availability", { toolId: TOOL_ID });
+    const rubyInfo = await (0, import_tooling.findRuby)(RUBY_VERSION_RANGE, ctx.logger).catch(() => null);
+    let resolvedRubyPath = rubyInfo?.path;
+    const dependencies = rubyInfo ? [{ name: "Ruby", available: true, version: rubyInfo.version, installation: "global" }] : [{ name: "Ruby", available: false, reason: `Ruby (${RUBY_VERSION_RANGE}) not found` }];
+    if (!rubyInfo) {
+      const rubyBin = (0, import_tooling.resolvePortableRubyBinary)(ctx.globalDir, "3.2.11");
+      try {
+        await import_promises.default.access(rubyBin);
+        resolvedRubyPath = rubyBin;
+        dependencies[0] = {
+          name: "Ruby",
+          available: true,
+          version: "3.2.11",
+          installation: "codacy"
+        };
+      } catch {
+        return {
+          available: false,
+          reason: "Ruby runtime not found (required for Reek)",
+          installHint: "Install Ruby 2.7+, or run with --install-dependencies for auto-download",
+          dependencies
+        };
+      }
+    }
+    const gemPaths = (0, import_tooling.getGemPaths)(ctx.globalDir, ADAPTER_ID);
+    const reekVersion = await (0, import_tooling.checkGemTool)(
+      gemPaths,
+      "reek",
+      "--version",
+      /reek\s+(\S+)/,
+      resolvedRubyPath,
+      ctx.logger
+    );
+    if (reekVersion) {
+      return {
+        available: true,
+        version: reekVersion,
+        path: (0, import_tooling.resolveGemBinary)(gemPaths, "reek"),
+        installation: "codacy",
+        dependencies
+      };
+    }
+    try {
+      const { stdout, exitCode } = await (0, import_tooling.spawnTool)("reek", ["--version"], {
+        cwd: ctx.repositoryRoot,
+        logger: ctx.logger
+      });
+      if (exitCode === 0) {
+        const match = stdout.match(/reek\s+(\S+)/);
+        if (match) {
+          return {
+            available: true,
+            version: match[1],
+            installation: "global",
+            dependencies
+          };
+        }
+      }
+    } catch {
+    }
+    return {
+      available: false,
+      reason: "Reek not found in Codacy gem directory or on PATH",
+      installHint: "Run with --install-dependencies to auto-install, or run: gem install reek",
+      dependencies
+    };
+  },
+  /**
+   * Installs Reek by ensuring a Ruby runtime is available and installing
+   * the reek gem into an isolated gem directory.
+   */
+  async install(ctx) {
+    ctx.logger.info("Starting install", { toolId: TOOL_ID });
+    const ruby = await (0, import_tooling.ensureRuby)(ctx.globalDir, RUBY_VERSION_RANGE, ctx.logger);
+    if (!ruby) {
+      return {
+        success: false,
+        error: {
+          toolId: TOOL_ID,
+          phase: "requirementCheck",
+          kind: "MissingPrerequisite",
+          message: `Ruby (${RUBY_VERSION_RANGE}) could not be found or downloaded. Reek requires a Ruby runtime.`,
+          level: "error"
+        }
+      };
+    }
+    try {
+      const gemPaths = (0, import_tooling.getGemPaths)(ctx.globalDir, ADAPTER_ID);
+      ctx.logger.info(`Installing Reek ${REEK_VERSION} to ${gemPaths.gemHome}...`);
+      await (0, import_tooling.gemInstall)(gemPaths, ruby.path, [`reek:${REEK_VERSION}`], ctx.logger);
+      const installedPath = (0, import_tooling.resolveGemBinary)(gemPaths, "reek");
+      ctx.logger.info(`Installed Reek to ${installedPath}`);
+      return { success: true, installedPath, installedVersion: REEK_VERSION };
+    } catch (err) {
+      return {
+        success: false,
+        error: {
+          toolId: TOOL_ID,
+          phase: "toolInstall",
+          kind: "InstallError",
+          message: `Failed to install Reek: ${err instanceof Error ? err.message : String(err)}`,
+          level: "error"
+        }
+      };
+    }
+  },
+  /**
+   * Checks for Reek configuration files in the repository root.
+   * Looks for `.reek.yml` or `config.reek` (in that order).
+   */
+  async checkLocalConfigurationFile(ctx) {
+    ctx.logger.debug("Checking for local config", { toolId: TOOL_ID });
+    for (const candidate of CONFIG_FILE_CANDIDATES) {
+      const candidatePath = import_path.default.join(ctx.repositoryRoot, candidate);
+      try {
+        await import_promises.default.access(candidatePath);
+        ctx.logger.debug("Local config found", { toolId: TOOL_ID, path: candidatePath });
+        return { found: true, path: candidatePath };
+      } catch {
+      }
+    }
+    return { found: false };
+  },
+  /**
+   * Runs Reek against the target Ruby files and converts the JSON output
+   * into Codacy Issue objects.
+   *
+   * Config resolution:
+   * - If `useLocalConfigurationFile` is true and a local config is found,
+   *   passes `--config <path>` to reek.
+   * - Otherwise, reek runs with defaults and output is post-filtered by
+   *   enabled patterns.
+   *
+   * Key details:
+   * - `--format json` produces a flat JSON array of smell objects.
+   * - Exit code 0 = no smells, 2 = smells found (both success), 1 = error.
+   * - The `lines` field is an array — we use `lines[0]` as the primary line.
+   * - Pattern IDs are bare smell type names (e.g. `FeatureEnvy`).
+   *
+   * 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);
+    }
+    const invocation = await resolveToolInvocation(ctx);
+    const absoluteFiles = ctx.targetFiles.map((f) => import_path.default.resolve(ctx.repositoryRoot, f));
+    const args = [...invocation.prefixArgs, "--format", "json"];
+    const useLocal = codacyConfig.useLocalConfigurationFile && codacyConfig.localConfigurationFile;
+    if (useLocal) {
+      args.push("--config", codacyConfig.localConfigurationFile);
+    }
+    args.push(...absoluteFiles);
+    try {
+      const gemPaths = (0, import_tooling.getGemPaths)(ctx.globalDir, ADAPTER_ID);
+      const env = (0, import_tooling.buildGemEnv)(gemPaths, invocation.rubyPath);
+      const { stdout, stderr, exitCode } = await (0, import_tooling.spawnTool)(invocation.binary, args, {
+        cwd: ctx.repositoryRoot,
+        env,
+        logger: ctx.logger
+      });
+      if (exitCode !== 0 && exitCode !== 2) {
+        errors.push({
+          toolId: TOOL_ID,
+          phase: "toolInvoke",
+          kind: "NonZeroExit",
+          message: `Reek 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 smells;
+      try {
+        smells = JSON.parse(stdout);
+      } catch (err) {
+        errors.push({
+          toolId: TOOL_ID,
+          phase: "outputParse",
+          kind: "MalformedOutput",
+          message: `Failed to parse Reek JSON output: ${err instanceof Error ? err.message : String(err)}`,
+          level: "error"
+        });
+        return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+      }
+      if (!Array.isArray(smells)) {
+        errors.push({
+          toolId: TOOL_ID,
+          phase: "outputParse",
+          kind: "MalformedOutput",
+          message: "Reek output is not a JSON array",
+          level: "error"
+        });
+        return buildResult(startedAt, /* @__PURE__ */ new Date(), issues, errors, ctx.targetFiles.length);
+      }
+      const enabledPatterns = new Set(codacyConfig.patterns.map((p) => p.patternId));
+      const fileLineCache = /* @__PURE__ */ new Map();
+      for (const smell of smells) {
+        const patternId = smell.smell_type;
+        if (!patternId) continue;
+        if (enabledPatterns.size > 0 && !enabledPatterns.has(patternId)) continue;
+        let filePath = smell.source;
+        if (import_path.default.isAbsolute(filePath)) {
+          filePath = import_path.default.relative(ctx.repositoryRoot, filePath);
+        }
+        const line = smell.lines?.[0] ?? 1;
+        const meta = ruleMetadata(patternId);
+        const absPath = import_path.default.resolve(ctx.repositoryRoot, filePath);
+        if (!fileLineCache.has(absPath)) {
+          fileLineCache.set(absPath, await readFileLines(absPath));
+        }
+        const fileLines = fileLineCache.get(absPath);
+        issues.push({
+          filePath,
+          patternId,
+          toolId: TOOL_ID,
+          line,
+          message: smell.message,
+          lineContent: getLineContent(fileLines, line),
+          category: meta.category,
+          severity: meta.severity
+        });
+      }
+      const stderrFiltered = stderr.split("\n").filter((l) => l.trim()).join("\n").trim();
+      if (stderrFiltered) {
+        errors.push({
+          toolId: TOOL_ID,
+          phase: "outputParse",
+          kind: "ParseWarning",
+          message: `Reek stderr: ${stderrFiltered}`,
+          level: "warning"
+        });
+      }
+    } catch (invokeErr) {
+      errors.push({
+        toolId: TOOL_ID,
+        phase: "toolInvoke",
+        kind: "InvocationError",
+        message: `Failed to run Reek: ${invokeErr instanceof Error ? invokeErr.message : String(invokeErr)}`,
+        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);

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@codacy/tools-reek-6",
+  "version": "0.2.0",
+  "description": "Reek adapter — CLI-mode Ruby code smell detector",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@codacy/tooling": "0.2.0"
+  },
+  "license": "MIT",
+  "author": "Codacy <support@codacy.com> (https://www.codacy.com)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/codacy/analysis-cli.git",
+    "directory": "packages/tools/reek-6"
+  },
+  "homepage": "https://github.com/codacy/analysis-cli",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs --dts --clean",
+    "test": "vitest run",
+    "lint": "eslint src/",
+    "clean": "rm -rf dist",
+    "prefetch": "node ../scripts/fetch-patterns.mjs ec8f6265-18e8-478a-a295-7a4c09fa2171 src/patterns.json"
+  }
+}