@codacy/tools-jackson 0.1.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,51 @@
+# @codacy/tools-jackson
+
+## Table of Contents
+- [Overview](#overview)
+- [Patterns](#patterns)
+- [Updating patterns](#updating-patterns)
+- [Development](#development)
+
+---
+
+## Overview
+
+Pure TypeScript JSON syntax validator using Node's built-in `JSON.parse`. Detects parse errors and duplicate keys in JSON files. No external binary required.
+
+| Property | Value |
+|----------|-------|
+| Tool ID | `jackson` |
+| Codacy UUID | `4f94ee55-6b76-4765-8f38-9ebb3920762b` |
+| Strategy | Native |
+| Languages | JSON |
+| Binary | None — pure TypeScript |
+
+## Patterns
+
+| Pattern ID | Description |
+|------------|-------------|
+| `jackson_parse-error` | JSON syntax error |
+| `jackson_duplicate-keys` | Duplicate keys in JSON object |
+
+## Updating patterns
+
+```bash
+# Re-fetch pattern metadata from the Codacy API
+pnpm prefetch
+
+# Verify the output
+cat 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.
+
+After fetching, commit the updated `src/patterns.json`.
+
+## Development
+
+```bash
+pnpm build    # Build with tsup
+pnpm test     # Run tests
+```
+
+Since this is a Native adapter, no external binary is needed. All analysis is done in TypeScript.

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,273 @@
+"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_tooling = require("@codacy/tooling");
+
+// src/adapter.ts
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+var TOOL_ID = "jackson";
+var PATTERN_PARSE_ERROR = `${TOOL_ID}_parse-error`;
+var PATTERN_DUPLICATE_KEYS = `${TOOL_ID}_duplicate-keys`;
+var adapter = {
+  id: TOOL_ID,
+  displayName: "Jackson Linter",
+  preferredVersion: "1.0.0",
+  compatibleVersions: ">=1.0.0",
+  website: "https://github.com/FasterXML/jackson-core",
+  languages: ["JSON"],
+  filePatterns: ["**/*.json"],
+  supportedOS: ["linux", "darwin", "win32"],
+  supportedArch: ["x64", "arm64"],
+  supportedRunners: ["local", "container"],
+  prerequisites: [],
+  /**
+   * Always available — this adapter uses only Node's built-in JSON.parse.
+   * No external binary or runtime installation is needed.
+   */
+  async checkAvailability(ctx) {
+    ctx.logger.debug("Checking availability", { toolId: TOOL_ID });
+    ctx.logger.debug("Availability check result", { toolId: TOOL_ID, available: true, version: "1.0.0" });
+    return { available: true, version: "1.0.0", installation: "bundled" };
+  },
+  /** No-op — there is nothing to install for a Native adapter. */
+  async install(ctx) {
+    ctx.logger.info("Starting install", { toolId: TOOL_ID });
+    ctx.logger.info("Install not needed \u2014 native adapter", { toolId: TOOL_ID });
+    return { success: true, installedVersion: "1.0.0" };
+  },
+  /**
+   * Jackson Linter has no native configuration file concept.
+   * Always returns `{ found: false }`.
+   */
+  async checkLocalConfigurationFile(ctx) {
+    ctx.logger.debug("Checking for local config", { toolId: TOOL_ID });
+    ctx.logger.debug("Local config check", { toolId: TOOL_ID, found: false, path: void 0 });
+    return { found: false };
+  },
+  /**
+   * Analyzes each target file by attempting JSON.parse (parse-error) and by
+   * scanning for duplicate object keys (duplicate-keys).
+   *
+   * Config filtering: when `codacyConfig.patterns` is non-empty, only the
+   * enabled patterns are checked. If patterns is empty (all rules enabled),
+   * both checks run.
+   *
+   * For each file:
+   * - If the file cannot be read, an AnalysisError with kind "FileReadError" is recorded.
+   * - If JSON.parse throws a SyntaxError, the error's character position is decoded
+   *   into a 1-based line/column and an Issue with patternId `jackson_parse-error` is emitted.
+   * - If duplicate object keys are found, each duplicate emits an Issue with patternId
+   *   `jackson_duplicate-keys`.
+   * - Valid JSON files with no duplicates produce no issues.
+   *
+   * This method never throws — all errors are collected and returned.
+   */
+  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 = [];
+    const enabledPatterns = new Set(codacyConfig.patterns.map((p) => p.patternId));
+    const checkParseError = enabledPatterns.size === 0 || enabledPatterns.has(PATTERN_PARSE_ERROR);
+    const checkDuplicateKeys = enabledPatterns.size === 0 || enabledPatterns.has(PATTERN_DUPLICATE_KEYS);
+    for (const relPath of ctx.targetFiles) {
+      const absPath = import_path.default.resolve(ctx.repositoryRoot, relPath);
+      let content;
+      try {
+        content = await import_promises.default.readFile(absPath, "utf-8");
+      } catch (err) {
+        errors.push({
+          toolId: TOOL_ID,
+          phase: "toolInvoke",
+          kind: "FileReadError",
+          message: `Cannot read file ${relPath}: ${err instanceof Error ? err.message : String(err)}`,
+          level: "warning",
+          filePath: relPath
+        });
+        continue;
+      }
+      let parseFailed = false;
+      if (checkParseError) {
+        try {
+          JSON.parse(content);
+        } catch (err) {
+          if (err instanceof SyntaxError) {
+            parseFailed = true;
+            const { line, column } = extractPosition(err.message, content);
+            const lines = content.split("\n");
+            const lineContent = lines[line - 1] ?? "";
+            issues.push({
+              filePath: relPath,
+              patternId: PATTERN_PARSE_ERROR,
+              toolId: TOOL_ID,
+              line,
+              column,
+              message: err.message,
+              lineContent,
+              category: "ErrorProne",
+              severity: "Error"
+            });
+          }
+        }
+      }
+      if (checkDuplicateKeys && !parseFailed) {
+        const duplicates = findDuplicateKeys(content);
+        const lines = content.split("\n");
+        for (const dup of duplicates) {
+          const lineContent = lines[dup.line - 1] ?? "";
+          issues.push({
+            filePath: relPath,
+            patternId: PATTERN_DUPLICATE_KEYS,
+            toolId: TOOL_ID,
+            line: dup.line,
+            column: dup.column,
+            message: `Duplicate key "${dup.key}"`,
+            lineContent,
+            category: "ErrorProne",
+            severity: "Warning"
+          });
+        }
+      }
+    }
+    const completedAt = /* @__PURE__ */ new Date();
+    ctx.logger.info("Analysis complete", { toolId: TOOL_ID, issueCount: issues.length, errorCount: errors.length, durationMs: Date.now() - startMs });
+    return {
+      metadata: {
+        startedAt: startedAt.toISOString(),
+        completedAt: completedAt.toISOString(),
+        durationMs: completedAt.getTime() - startedAt.getTime()
+      },
+      issues,
+      errors,
+      summary: {
+        toolId: TOOL_ID,
+        status: errors.some((e) => e.level === "error") ? "partial" : "success",
+        issueCount: issues.length,
+        errorCount: errors.length,
+        durationMs: completedAt.getTime() - startedAt.getTime(),
+        filesAnalyzed: ctx.targetFiles.length
+      }
+    };
+  }
+};
+function extractPosition(message, source) {
+  const posMatch = message.match(/position (\d+)/);
+  if (posMatch) {
+    const pos = parseInt(posMatch[1], 10);
+    return positionToLineColumn(source, pos);
+  }
+  return { line: 1, column: 1 };
+}
+function positionToLineColumn(src, position) {
+  const before = src.slice(0, Math.min(position, src.length));
+  const lines = before.split("\n");
+  const line = lines.length;
+  const column = (lines[lines.length - 1]?.length ?? 0) + 1;
+  return { line, column };
+}
+function findDuplicateKeys(source) {
+  const duplicates = [];
+  const stack = [];
+  let i = 0;
+  const len = source.length;
+  let line = 1;
+  let col = 1;
+  while (i < len) {
+    const ch = source[i];
+    if (ch === '"') {
+      const strLine = line;
+      const strCol = col;
+      let strVal = "";
+      i++;
+      col++;
+      while (i < len) {
+        const sc = source[i];
+        if (sc === "\\") {
+          strVal += sc;
+          i++;
+          col++;
+          if (i < len) {
+            strVal += source[i];
+            i++;
+            col++;
+          }
+        } else if (sc === '"') {
+          i++;
+          col++;
+          break;
+        } else {
+          if (sc === "\n") {
+            line++;
+            col = 1;
+          } else {
+            col++;
+          }
+          strVal += sc;
+          i++;
+        }
+      }
+      let j = i;
+      while (j < len && (source[j] === " " || source[j] === "	" || source[j] === "\n" || source[j] === "\r")) {
+        j++;
+      }
+      if (source[j] === ":" && stack.length > 0) {
+        const currentKeys = stack[stack.length - 1];
+        if (currentKeys.has(strVal)) {
+          duplicates.push({ key: strVal, line: strLine, column: strCol });
+        } else {
+          currentKeys.add(strVal);
+        }
+      }
+      continue;
+    } else if (ch === "{") {
+      stack.push(/* @__PURE__ */ new Set());
+    } else if (ch === "}") {
+      stack.pop();
+    } else if (ch === "\n") {
+      line++;
+      col = 1;
+      i++;
+      continue;
+    }
+    i++;
+    col++;
+  }
+  return duplicates;
+}
+
+// src/index.ts
+var index_default = (0, import_tooling.defineToolAdapter)(adapter);

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@codacy/tools-jackson",
+  "version": "0.1.0",
+  "description": "Jackson Linter adapter — pure TypeScript JSON syntax validator",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@codacy/tooling": "0.1.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/jackson"
+  },
+  "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 4f94ee55-6b76-4765-8f38-9ebb3920762b src/patterns.json"
+  }
+}