@codacy/tools-unsupported-tools 0.10.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,111 @@
+# @codacy/tools-unsupported-tools
+
+## Table of Contents
+
+- [Overview](#overview)
+- [What "unsupported" means](#what-unsupported-means)
+- [Contents](#contents)
+- [Framework mappings](#framework-mappings)
+- [Regenerating the manifest](#regenerating-the-manifest)
+- [How it's consumed](#how-its-consumed)
+- [Development](#development)
+- [Notes for maintainers](#notes-for-maintainers)
+
+## Overview
+
+This package holds a **generated, committed manifest** of every Codacy Cloud tool
+that does **not** have a local analyzer adapter in this CLI — the "unsupported"
+(cloud-only) tools. It lets the CLI treat those tools as first-class citizens of
+the configuration and of the `info` / `analyze` / `init` flows, even though they
+are never executed locally.
+
+## What "unsupported" means
+
+A tool is tracked here when it is in the Codacy catalog (`/api/v3/tools`), has **no
+local adapter** (its UUID is not referenced by any sibling tool package's
+`prefetch` script), and is **trackable** — i.e. not deprecated and not
+client-side/standalone-only (those run only in the customer environment).
+
+Descriptors carry `unsupported: true`, which is how the rest of the CLI tells them
+apart from real adapters.
+
+## Contents
+
+- `src/descriptors.json` — one `AdapterDescriptor` per tool (`unsupported: true`,
+  `uuid` set, `supportedRunners: ["container"]`).
+- `src/patterns/<toolId>.json` — that tool's full pattern set (same shape as a
+  supported adapter's `patterns.json`). Tools with no patterns have no file.
+- `src/index.ts` — exports `unsupportedDescriptors` (eager, tiny) and
+  `loadUnsupportedPatterns(toolId)` (lazy disk read, cached).
+- `src/framework-mappings.json` — hand-curated framework matching rules (see below).
+
+## Framework mappings
+
+Several cloud-only tools ship framework-specific patterns (PHPCS → CakePHP/WordPress/Drupal/Magento/
+Symfony; dartanalyzer → Flutter/Angular; SonarCSharp → ASP.NET Core/Entity Framework/xUnit/…;
+CodeNarc → Grails/Spock/…). `src/framework-mappings.json` maps **tool ID → `FrameworkMappings`** so
+`init --auto` can include those patterns only when the framework is actually detected (and exclude
+them otherwise), exactly like supported tools.
+
+- It is **hand-curated and committed** — unlike `descriptors.json`/`patterns/`, it is **not** touched
+  by `generate`, so it survives regeneration. `index.ts` merges it onto each descriptor's
+  `frameworkMappings` at load time.
+- Choose the mechanism per tool from its pattern shape: `prefixes` when pattern IDs are namespaced by
+  framework (e.g. `PHPCS_CakePHP_`), `tags` otherwise (e.g. `flutter`, `aspnetcore`, `grails`).
+- Each **key must equal the discover catalog `displayName`** for that framework
+  (`packages/runner/src/discover-catalog.ts`) — that's what auto-init matches against. Add a catalog
+  entry + manifest parser there if discover can't yet detect the framework.
+- `test/framework-mappings.test.ts` enforces that every key maps to a real tool, the merge applied,
+  and every prefix/tag still matches ≥1 committed pattern (guards against drift after regeneration).
+
+## Regenerating the manifest
+
+From the repo root:
+
+```bash
+pnpm generate-unsupported
+```
+
+or from this package:
+
+```bash
+pnpm generate
+```
+
+The script (`scripts/generate.mjs`) fetches the catalog, subtracts locally
+supported tools (by UUID, read from sibling `prefetch` scripts — no list to keep
+in sync), filters out deprecated/client-side tools, and rewrites
+`descriptors.json` + `patterns/`. Commit the result. On network failure it warns
+and exits 0, leaving committed files untouched.
+
+Run this whenever Codacy adds/removes tools or you implement a new local adapter
+(which should then disappear from this manifest on the next regeneration).
+
+## How it's consumed
+
+- `packages/cli/src/index.ts` registers every descriptor via
+  `registerUnsupportedTool()` so they appear in `getRegisteredDescriptors()`.
+- `init --auto` calls `loadUnsupportedPatterns()` to fill cloud-only tools offline.
+- `init --remote` / `--default` fetch patterns from the API at runtime, so they
+  do not read this package's pattern files — only its descriptors/registration.
+
+## Development
+
+```bash
+pnpm build   # tsup bundle + copy src/patterns → dist/patterns
+pnpm test    # manifest shape + drift invariants
+pnpm lint
+```
+
+`loadUnsupportedPatterns` reads `dist/patterns/<toolId>.json` at runtime
+(`__dirname`-relative) and `src/patterns/` during tests.
+
+## Notes for maintainers
+
+- The patterns directory is **recreated** on every `generate` run so removed tools
+  don't leave stale files behind.
+- The package is named with the `@codacy/tools-` prefix on purpose: the CLI keeps
+  those external from its bundle, so `__dirname` resolves to this package's own
+  `dist/` and the pattern files are found.
+- `filePatterns` is `["*"]` for all entries — unsupported tools never route files
+  locally, so the value is cosmetic.

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+import { PatternEntry, AdapterDescriptor } from '@codacy/tooling';
+
+/**
+ * @codacy/tools-unsupported-tools — generated manifest of Codacy Cloud tools
+ * that have no local analyzer in this CLI ("unsupported"/cloud-only tools).
+ *
+ * The manifest is produced by `scripts/generate.mjs` (run `pnpm generate` here,
+ * or `pnpm generate-unsupported` from the repo root) and committed:
+ *   - `descriptors.json` — one `AdapterDescriptor` per tool (`unsupported: true`).
+ *   - `patterns/<toolId>.json` — that tool's full pattern set.
+ *
+ * Descriptors are tiny and imported eagerly so CLI startup can register every
+ * cloud-only tool. Patterns are large and read lazily from disk only when a
+ * flow actually needs them (currently `init --auto`).
+ */
+
+/**
+ * Descriptors for every tracked cloud-only tool. Each has `unsupported: true`.
+ * Tools with curated framework mappings get them attached here so auto-init can
+ * gate their framework-specific patterns on detected frameworks/libraries.
+ */
+declare const unsupportedDescriptors: AdapterDescriptor[];
+/**
+ * Lazily loads the committed pattern set for an unsupported tool by its tool ID.
+ * Returns an empty array when the tool has no committed patterns (or the file is
+ * missing). Results are cached. Reads from `dist/patterns/` at runtime (the
+ * directory is copied there at build time) and `src/patterns/` during tests.
+ */
+declare function loadUnsupportedPatterns(toolId: string): readonly PatternEntry[];
+
+export { loadUnsupportedPatterns, unsupportedDescriptors };

package/dist/index.js

@@ -0,0 +1,261 @@
+"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, {
+  loadUnsupportedPatterns: () => loadUnsupportedPatterns,
+  unsupportedDescriptors: () => unsupportedDescriptors
+});
+module.exports = __toCommonJS(index_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+
+// src/descriptors.json
+var descriptors_default = [
+  {
+    id: "ameba",
+    displayName: "Ameba",
+    preferredVersion: "1.6.4",
+    languages: ["Crystal"],
+    filePatterns: ["*"],
+    supportedOS: ["linux", "darwin", "win32"],
+    supportedArch: ["x64", "arm64"],
+    supportedRunners: ["container"],
+    uuid: "29815f43-c1d4-40e9-a9ad-27423209fa7b",
+    unsupported: true
+  },
+  {
+    id: "codacy-scalameta-pro",
+    displayName: "Codacy ScalaMeta Pro",
+    preferredVersion: "",
+    languages: ["Scala"],
+    filePatterns: ["*"],
+    supportedOS: ["linux", "darwin", "win32"],
+    supportedArch: ["x64", "arm64"],
+    supportedRunners: ["container"],
+    uuid: "647dddc1-17c4-4840-acea-4c2c2bbecb45",
+    unsupported: true
+  },
+  {
+    id: "CodeNarc",
+    displayName: "CodeNarc",
+    preferredVersion: "3.6.0",
+    languages: ["Groovy"],
+    filePatterns: ["*"],
+    supportedOS: ["linux", "darwin", "win32"],
+    supportedArch: ["x64", "arm64"],
+    supportedRunners: ["container"],
+    uuid: "d87d5570-a63c-4014-98ab-f446816ae67b",
+    unsupported: true
+  },
+  {
+    id: "coffeelint",
+    displayName: "CoffeeLint",
+    preferredVersion: "5.2.11",
+    languages: ["CoffeeScript"],
+    filePatterns: ["*"],
+    supportedOS: ["linux", "darwin", "win32"],
+    supportedArch: ["x64", "arm64"],
+    supportedRunners: ["container"],
+    uuid: "6d94ef22-1eb6-4968-821e-291c26dd9d4c",
+    unsupported: true
+  },
+  {
+    id: "Credo",
+    displayName: "Credo",
+    preferredVersion: "1.7.12",
+    languages: ["Elixir"],
+    filePatterns: ["*"],
+    supportedOS: ["linux", "darwin", "win32"],
+    supportedArch: ["x64", "arm64"],
+    supportedRunners: ["container"],
+    uuid: "68feeeae-4432-41aa-bee0-95d979c930de",
+    unsupported: true
+  },
+  {
+    id: "dartanalyzer",
+    displayName: "dartanalyzer",
+    preferredVersion: "3.9.3",
+    languages: ["Dart"],
+    filePatterns: ["*"],
+    supportedOS: ["linux", "darwin", "win32"],
+    supportedArch: ["x64", "arm64"],
+    supportedRunners: ["container"],
+    uuid: "d203d615-6cf1-41f9-be5f-e2f660f7850f",
+    unsupported: true
+  },
+  {
+    id: "PHPCS",
+    displayName: "PHP_CodeSniffer",
+    preferredVersion: "3.10.1",
+    languages: ["PHP"],
+    filePatterns: ["*"],
+    supportedOS: ["linux", "darwin", "win32"],
+    supportedArch: ["x64", "arm64"],
+    supportedRunners: ["container"],
+    uuid: "f67f7669-fff1-4f28-8a37-b665e5ebd182",
+    unsupported: true
+  },
+  {
+    id: "phpmd",
+    displayName: "PHP Mess Detector",
+    preferredVersion: "2.14.1",
+    languages: ["PHP"],
+    filePatterns: ["*"],
+    supportedOS: ["linux", "darwin", "win32"],
+    supportedArch: ["x64", "arm64"],
+    supportedRunners: ["container"],
+    uuid: "3d0db474-e352-4afb-90a2-9c0785b8d2fd",
+    unsupported: true
+  },
+  {
+    id: "psscriptanalyzer",
+    displayName: "PSScriptAnalyzer",
+    preferredVersion: "1.24.0",
+    languages: ["Powershell"],
+    filePatterns: ["*"],
+    supportedOS: ["linux", "darwin", "win32"],
+    supportedArch: ["x64", "arm64"],
+    supportedRunners: ["container"],
+    uuid: "8fb0fb29-fa6e-43f2-9a73-9cd3873b4d8a",
+    unsupported: true
+  },
+  {
+    id: "remark-lint",
+    displayName: "remark-lint",
+    preferredVersion: "10.0.1",
+    languages: ["Markdown"],
+    filePatterns: ["*"],
+    supportedOS: ["linux", "darwin", "win32"],
+    supportedArch: ["x64", "arm64"],
+    supportedRunners: ["container"],
+    uuid: "f1eec388-0526-4c6c-954e-9b20b51bd9e7",
+    unsupported: true
+  },
+  {
+    id: "SonarCSharp",
+    displayName: "SonarC#",
+    preferredVersion: "9.32",
+    languages: ["CSharp"],
+    filePatterns: ["*"],
+    supportedOS: ["linux", "darwin", "win32"],
+    supportedArch: ["x64", "arm64"],
+    supportedRunners: ["container"],
+    uuid: "8954dff3-f19c-429c-ac76-c45fa5e73b62",
+    unsupported: true
+  },
+  {
+    id: "SonarVisualBasic",
+    displayName: "SonarVB",
+    preferredVersion: "8.15",
+    languages: ["VisualBasic"],
+    filePatterns: ["*"],
+    supportedOS: ["linux", "darwin", "win32"],
+    supportedArch: ["x64", "arm64"],
+    supportedRunners: ["container"],
+    uuid: "a5feaa2e-4abd-4416-81aa-641d012ec1d1",
+    unsupported: true
+  },
+  {
+    id: "TSQLLint",
+    displayName: "TSQLLint",
+    preferredVersion: "1.16.0",
+    languages: ["SQL", "TSQL"],
+    filePatterns: ["*"],
+    supportedOS: ["linux", "darwin", "win32"],
+    supportedArch: ["x64", "arm64"],
+    supportedRunners: ["container"],
+    uuid: "35cf97c2-6548-483e-baf9-549433891295",
+    unsupported: true
+  }
+];
+
+// src/framework-mappings.json
+var framework_mappings_default = {
+  PHPCS: {
+    CakePHP: { prefixes: ["PHPCS_CakePHP_"] },
+    WordPress: { prefixes: ["PHPCS_WordPress_", "PHPCS_WordPressVIPMinimum_"] },
+    Drupal: { prefixes: ["PHPCS_Drupal_"] },
+    Magento: { prefixes: ["PHPCS_Magento2_", "PHPCS_Magento2Framework_", "PHPCS_MEQP1_"] },
+    Symfony: { prefixes: ["PHPCS_Symfony_"] }
+  },
+  dartanalyzer: {
+    Flutter: { tags: ["flutter"] },
+    Angular: { tags: ["angular"] }
+  },
+  SonarCSharp: {
+    "ASP.NET Core": { tags: ["aspnetcore"] },
+    Blazor: { tags: ["blazor"] },
+    "Entity Framework": { tags: ["entityframework", "entityframeworkcore"] },
+    xUnit: { tags: ["xunit"] },
+    NUnit: { tags: ["nunit"] },
+    MSTest: { tags: ["mstest"] },
+    Moq: { tags: ["moq"] },
+    NSubstitute: { tags: ["nsubstitute"] },
+    FluentAssertions: { tags: ["fluentassertions"] },
+    Shouldly: { tags: ["shouldly"] },
+    Serilog: { tags: ["serilog"] },
+    NLog: { tags: ["nlog"] },
+    log4net: { tags: ["log4net", "apachelog4net"] }
+  },
+  CodeNarc: {
+    Grails: { tags: ["grails"] },
+    GORM: { tags: ["gorm"] },
+    Spock: { tags: ["spock"] },
+    Jenkins: { tags: ["jenkins", "jenkinspipeline"] },
+    JUnit: { tags: ["junit"] }
+  }
+};
+
+// src/index.ts
+var frameworkMappingsByTool = framework_mappings_default;
+var unsupportedDescriptors = descriptors_default.map((descriptor) => {
+  const frameworkMappings = frameworkMappingsByTool[descriptor.id];
+  return frameworkMappings ? { ...descriptor, frameworkMappings } : descriptor;
+});
+var patternsCache = /* @__PURE__ */ new Map();
+function loadUnsupportedPatterns(toolId) {
+  const cached = patternsCache.get(toolId);
+  if (cached) return cached;
+  const file = import_path.default.join(__dirname, "patterns", `${import_path.default.basename(toolId)}.json`);
+  let patterns = [];
+  try {
+    patterns = JSON.parse(import_fs.default.readFileSync(file, "utf-8"));
+  } catch {
+    patterns = [];
+  }
+  patternsCache.set(toolId, patterns);
+  return patterns;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadUnsupportedPatterns,
+  unsupportedDescriptors
+});