@codacy/tools-markdownlint-0 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,56 @@
+# @codacy/tools-markdownlint-0
+
+## Table of Contents
+- [Overview](#overview)
+- [Updating patterns](#updating-patterns)
+- [Updating the markdownlint version](#updating-the-markdownlint-version)
+- [Development](#development)
+- [Notes for maintainers](#notes-for-maintainers)
+
+---
+
+## Overview
+
+Markdown linter using the [markdownlint](https://github.com/DavidAnson/markdownlint) Node.js library. Uses the Library execution strategy — calls the markdownlint API directly rather than spawning a subprocess.
+
+| Property | Value |
+|----------|-------|
+| Tool ID | `markdownlint` |
+| Codacy UUID | `547ff16b-d57c-4d75-8067-5ccf3ea88a00` |
+| Strategy | Library |
+| Languages | Markdown |
+| Dependency | `markdownlint` npm package (v0.x) |
+| File patterns | `**/*.md` |
+
+## Updating patterns
+
+```bash
+# Re-fetch pattern metadata from the Codacy API
+pnpm prefetch
+
+# Commit the result
+git add src/patterns.json
+```
+
+Pattern IDs follow the format `markdownlint_MD001`, `markdownlint_MD013`, etc.
+
+## Updating the markdownlint version
+
+1. Update the `markdownlint` version in `package.json`
+2. Run `pnpm install`
+3. Run `pnpm prefetch` to check for new/removed rules
+4. Run `pnpm test` to verify compatibility
+5. If the major version changes, create a new adapter package (`markdownlint-1/`)
+
+## Development
+
+```bash
+pnpm build    # Build with tsup
+pnpm test     # Run tests
+```
+
+## Notes for maintainers
+
+- markdownlint v0.37+ is **pure ESM**. The adapter uses `dynamic import()` at runtime to stay CJS-compatible with the tsup build.
+- `checkAvailability` dynamically imports markdownlint and checks its version.
+- `install` is a no-op — the npm dependency handles installation.

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,1001 @@
+"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_path = __toESM(require("path"));
+var import_fs = __toESM(require("fs"));
+
+// src/patterns.json
+var patterns_default = [
+  {
+    id: "markdownlint_MD001",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce Incremental Heading Levels",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "markdownlint_MD003",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Consistent Heading Style",
+    enabled: true,
+    parameters: [
+      {
+        name: "style",
+        default: "consistent",
+        description: "Heading style"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD004",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Consistent Unordered List Style",
+    enabled: true,
+    parameters: [
+      {
+        name: "style",
+        default: "consistent",
+        description: "List style"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD005",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce consistent indentation for list items at the same level",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "markdownlint_MD007",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Unordered List Indentation",
+    enabled: true,
+    parameters: [
+      {
+        name: "indent",
+        default: "2",
+        description: "Spaces for indent"
+      },
+      {
+        name: "start_indent",
+        default: "2",
+        description: "Spaces for first level indent (when start_indented is set)"
+      },
+      {
+        name: "start_indented",
+        default: "false",
+        description: "Whether to indent the first level of the list"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD009",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Trailing Spaces",
+    enabled: false,
+    parameters: [
+      {
+        name: "br_spaces",
+        default: "2",
+        description: "Spaces for line break"
+      },
+      {
+        name: "list_item_empty_lines",
+        default: "false",
+        description: "Allow spaces for empty lines in list items"
+      },
+      {
+        name: "strict",
+        default: "false",
+        description: "Include unnecessary breaks"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD010",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Hard Tabs",
+    enabled: true,
+    parameters: [
+      {
+        name: "code_blocks",
+        default: "true",
+        description: "Include code blocks"
+      },
+      {
+        name: "ignore_code_languages",
+        default: "[]",
+        description: "Fenced code languages to ignore"
+      },
+      {
+        name: "spaces_per_tab",
+        default: "1",
+        description: "Number of spaces for each hard tab"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD011",
+    category: "ErrorProne",
+    severityLevel: "Warning",
+    title: "Avoid Reversed Link Syntax",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "markdownlint_MD012",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Disallow Multiple Consecutive Blank Lines",
+    enabled: true,
+    parameters: [
+      {
+        name: "maximum",
+        default: "1",
+        description: "Consecutive blank lines"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD013",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Maximum Line Length",
+    enabled: false,
+    parameters: [
+      {
+        name: "code_block_line_length",
+        default: "80",
+        description: "Number of characters for code blocks"
+      },
+      {
+        name: "code_blocks",
+        default: "true",
+        description: "Include code blocks"
+      },
+      {
+        name: "heading_line_length",
+        default: "80",
+        description: "Number of characters for headings"
+      },
+      {
+        name: "headings",
+        default: "true",
+        description: "Include headings"
+      },
+      {
+        name: "line_length",
+        default: "80",
+        description: "Number of characters"
+      },
+      {
+        name: "stern",
+        default: "false",
+        description: "Stern length checking"
+      },
+      {
+        name: "strict",
+        default: "false",
+        description: "Strict length checking"
+      },
+      {
+        name: "tables",
+        default: "true",
+        description: "Include tables"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD014",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Dollar Signs Before Commands Without Showing Output",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "markdownlint_MD018",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce space after hash in ATX style heading",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "markdownlint_MD019",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Multiple Spaces After Hash in ATX Style Heading",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "markdownlint_MD020",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Space Inside Hashes on Closed Atx Style Headings",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "markdownlint_MD021",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Multiple Spaces Inside Hashes on Closed ATX Style Headings",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "markdownlint_MD022",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Headings Surrounded by Blank Lines",
+    enabled: true,
+    parameters: [
+      {
+        name: "lines_above",
+        default: "1",
+        description: "Blank lines above heading"
+      },
+      {
+        name: "lines_below",
+        default: "1",
+        description: "Blank lines below heading"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD023",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Headings Start at Beginning of Line",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "markdownlint_MD024",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Avoid Multiple Headings with the Same Content",
+    enabled: true,
+    parameters: [
+      {
+        name: "siblings_only",
+        default: "false",
+        description: "Only check sibling headings"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD025",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce Single Top-Level Heading in Markdown Document",
+    enabled: true,
+    parameters: [
+      {
+        name: "front_matter_title",
+        default: "^\\s*title\\s*[:=]",
+        description: "RegExp for matching title in front matter"
+      },
+      {
+        name: "level",
+        default: "1",
+        description: "Heading level"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD026",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Trailing Punctuation in Headings",
+    enabled: true,
+    parameters: [
+      {
+        name: "punctuation",
+        default: ".,;:!\u3002\uFF0C\uFF1B\uFF1A\uFF01",
+        description: "Punctuation characters"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD027",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Multiple Spaces After Blockquote Symbol",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "markdownlint_MD028",
+    category: "Comprehensibility",
+    severityLevel: "Info",
+    title: "Avoid Blank Line Inside Blockquote",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "markdownlint_MD029",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Ordered List Item Prefix Consistency",
+    enabled: true,
+    parameters: [
+      {
+        name: "style",
+        default: "one_or_ordered",
+        description: "List style"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD030",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Spaces After List Markers",
+    enabled: true,
+    parameters: [
+      {
+        name: "ol_multi",
+        default: "1",
+        description: "Spaces for multi-line ordered list items"
+      },
+      {
+        name: "ol_single",
+        default: "1",
+        description: "Spaces for single-line ordered list items"
+      },
+      {
+        name: "ul_multi",
+        default: "1",
+        description: "Spaces for multi-line unordered list items"
+      },
+      {
+        name: "ul_single",
+        default: "1",
+        description: "Spaces for single-line unordered list items"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD031",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce blank lines surrounding fenced code blocks",
+    enabled: false,
+    parameters: [
+      {
+        name: "list_items",
+        default: "true",
+        description: "Include list items"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD032",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Lists Surrounded by Blank Lines",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "markdownlint_MD033",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Disallow Inline HTML in Markdown",
+    enabled: true,
+    parameters: [
+      {
+        name: "allowed_elements",
+        default: "[]",
+        description: "Allowed elements"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD034",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce Angle Brackets Around Bare URLs",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "markdownlint_MD035",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Consistent Horizontal Rule Style",
+    enabled: true,
+    parameters: [
+      {
+        name: "style",
+        default: "consistent",
+        description: "Horizontal rule style"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD036",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Avoid Using Emphasis Instead of Headings",
+    enabled: true,
+    parameters: [
+      {
+        name: "punctuation",
+        default: ".,;:!?\u3002\uFF0C\uFF1B\uFF1A\uFF01\uFF1F",
+        description: "Punctuation characters"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD037",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Disallow Spaces Inside Emphasis Markers",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "markdownlint_MD038",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Disallow Spaces Inside Code Span Elements",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "markdownlint_MD039",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Avoid Spaces Inside Link Text",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "markdownlint_MD040",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce language specification in fenced code blocks",
+    enabled: false,
+    parameters: [
+      {
+        name: "allowed_languages",
+        default: "[]",
+        description: "List of languages"
+      },
+      {
+        name: "language_only",
+        default: "false",
+        description: "Require language only"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD041",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce First Line as Top-Level Heading",
+    enabled: false,
+    parameters: [
+      {
+        name: "front_matter_title",
+        default: "^\\s*title\\s*[:=]",
+        description: "RegExp for matching title in front matter"
+      },
+      {
+        name: "level",
+        default: "1",
+        description: "Heading level"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD042",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Disallow Empty Links",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "markdownlint_MD043",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce Required Heading Structure",
+    enabled: false,
+    parameters: [
+      {
+        name: "headings",
+        default: "[]",
+        description: "List of headings"
+      },
+      {
+        name: "match_case",
+        default: "false",
+        description: "Match case of headings"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD044",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Proper Capitalization of Proper Names",
+    enabled: true,
+    parameters: [
+      {
+        name: "code_blocks",
+        default: "true",
+        description: "Include code blocks"
+      },
+      {
+        name: "html_elements",
+        default: "true",
+        description: "Include HTML elements"
+      },
+      {
+        name: "names",
+        default: "[]",
+        description: "List of proper names"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD045",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce Images to Have Alternate Text (alt text)",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "markdownlint_MD046",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce consistent code block style",
+    enabled: true,
+    parameters: [
+      {
+        name: "style",
+        default: "consistent",
+        description: "Block style"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD047",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Single Trailing Newline at End of File",
+    enabled: false,
+    parameters: []
+  },
+  {
+    id: "markdownlint_MD048",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Consistent Code Fence Style",
+    enabled: true,
+    parameters: [
+      {
+        name: "style",
+        default: "consistent",
+        description: "Code fence style"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD049",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Consistent Emphasis Style",
+    enabled: true,
+    parameters: [
+      {
+        name: "style",
+        default: "consistent",
+        description: "Emphasis style"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD050",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Consistent Strong Style",
+    enabled: true,
+    parameters: [
+      {
+        name: "style",
+        default: "consistent",
+        description: "Strong style"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD051",
+    category: "ErrorProne",
+    severityLevel: "Warning",
+    title: "Enforce Valid Link Fragments in Markdown",
+    enabled: true,
+    parameters: []
+  },
+  {
+    id: "markdownlint_MD052",
+    category: "ErrorProne",
+    severityLevel: "Warning",
+    title: "Enforce Defined Labels for Reference Links and Images",
+    enabled: true,
+    parameters: [
+      {
+        name: "shortcut_syntax",
+        default: "false",
+        description: "Include shortcut syntax"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD053",
+    category: "BestPractice",
+    severityLevel: "Warning",
+    title: "Enforce Link and Image Reference Definitions Are Needed",
+    enabled: true,
+    parameters: [
+      {
+        name: "ignored_definitions",
+        default: '["//"]',
+        description: "Ignored definitions"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD054",
+    category: "BestPractice",
+    severityLevel: "Info",
+    title: "Enforce Consistent Link and Image Style in Markdown",
+    enabled: true,
+    parameters: [
+      {
+        name: "autolink",
+        default: "true",
+        description: "Allow autolinks"
+      },
+      {
+        name: "collapsed",
+        default: "true",
+        description: "Allow collapsed reference links and images"
+      },
+      {
+        name: "full",
+        default: "true",
+        description: "Allow full reference links and images"
+      },
+      {
+        name: "inline",
+        default: "true",
+        description: "Allow inline links and images"
+      },
+      {
+        name: "shortcut",
+        default: "true",
+        description: "Allow shortcut reference links and images"
+      },
+      {
+        name: "url_inline",
+        default: "true",
+        description: "Allow URLs as inline links"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD055",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Table Pipe Style Consistency",
+    enabled: true,
+    parameters: [
+      {
+        name: "style",
+        default: "consistent",
+        description: "Table pipe style"
+      }
+    ]
+  },
+  {
+    id: "markdownlint_MD056",
+    category: "CodeStyle",
+    severityLevel: "Info",
+    title: "Enforce Consistent Table Column Count",
+    enabled: true,
+    parameters: []
+  }
+];
+
+// src/adapter.ts
+var TOOL_ID = "markdownlint";
+var LOCAL_CONFIG_FILES = [
+  ".markdownlint.json",
+  ".markdownlint.yaml",
+  ".markdownlint.yml",
+  ".markdownlintrc"
+];
+var PATTERN_META = new Map(
+  patterns_default.map((p) => [
+    p.id,
+    {
+      category: p.category,
+      severity: p.severityLevel ?? "Info"
+    }
+  ])
+);
+function ruleMetadata(ruleId) {
+  const patternId = `${TOOL_ID}_${ruleId}`;
+  return PATTERN_META.get(patternId) ?? { category: "Documentation", severity: "Info" };
+}
+function buildMarkdownlintConfig(patterns) {
+  const config = { default: false };
+  const prefix = `${TOOL_ID}_`;
+  for (const p of patterns) {
+    const ruleId = p.patternId.startsWith(prefix) ? p.patternId.slice(prefix.length) : p.patternId;
+    config[ruleId] = true;
+  }
+  return config;
+}
+function readLine(filePath, lineNumber) {
+  try {
+    const content = import_fs.default.readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+    return lines[lineNumber - 1] ?? "";
+  } catch {
+    return "";
+  }
+}
+async function importMarkdownlintSync() {
+  return import("markdownlint/sync");
+}
+var adapter = {
+  id: TOOL_ID,
+  displayName: "markdownlint",
+  preferredVersion: "0.37.4",
+  compatibleVersions: ">=0.30.0 <1.0.0",
+  website: "https://github.com/DavidAnson/markdownlint",
+  languages: ["Markdown"],
+  filePatterns: ["**/*.md", "**/*.markdown"],
+  supportedOS: ["linux", "darwin", "win32"],
+  supportedArch: ["x64", "arm64"],
+  supportedRunners: ["local", "container"],
+  prerequisites: [],
+  /**
+   * Verifies that the `markdownlint` npm package is loadable and returns its
+   * installed version via the `getVersion()` function it exports.
+   *
+   * Because markdownlint is declared as a direct runtime dependency, it is
+   * always present after installation — this check primarily surfaces the
+   * version for logging and capability reports.
+   */
+  async checkAvailability(ctx) {
+    ctx.logger.debug("Checking availability", { toolId: TOOL_ID });
+    try {
+      const mod = await import("markdownlint");
+      const version = mod.getVersion();
+      ctx.logger.debug("Availability check result", { toolId: TOOL_ID, available: true, version });
+      return { available: true, version, installation: "bundled" };
+    } catch (err) {
+      const reason = `markdownlint package not loadable: ${err instanceof Error ? err.message : String(err)}`;
+      ctx.logger.debug("Availability check result", { toolId: TOOL_ID, available: false, reason });
+      return { available: false, reason };
+    }
+  },
+  /**
+   * No-op — markdownlint is an npm dependency and requires no runtime
+   * installation step.
+   */
+  async install(ctx) {
+    ctx.logger.info("Starting install", { toolId: TOOL_ID });
+    ctx.logger.info("Install not needed \u2014 npm dependency", { toolId: TOOL_ID });
+    return { success: true, installedVersion: adapter.preferredVersion };
+  },
+  /**
+   * Looks for any of the standard markdownlint config file names in the
+   * repository root. Returns the path to the first one found, or `found: false`
+   * if none are present.
+   */
+  async checkLocalConfigurationFile(ctx) {
+    ctx.logger.debug("Checking for local config", { toolId: TOOL_ID });
+    for (const name of LOCAL_CONFIG_FILES) {
+      const candidate = import_path.default.join(ctx.repositoryRoot, name);
+      try {
+        import_fs.default.accessSync(candidate);
+        ctx.logger.debug("Local config check", { toolId: TOOL_ID, found: true, path: candidate });
+        return { found: true, path: candidate };
+      } catch {
+      }
+    }
+    ctx.logger.debug("Local config check", { toolId: TOOL_ID, found: false, path: void 0 });
+    return { found: false };
+  },
+  /**
+   * Runs markdownlint against the target files and converts the results to
+   * Codacy Issue objects.
+   *
+   * Config resolution order:
+   * 1. If `useLocalConfigurationFile` is true, read the project's native config
+   *    file via `readConfig()` and pass it as the inline config object.
+   * 2. If Codacy patterns are configured, build an inline config enabling only
+   *    those rules (all others disabled via `default: false`).
+   * 3. Otherwise, run with markdownlint's built-in default rule set.
+   *
+   * Category and severity for each issue are sourced from patterns.json (which
+   * is generated by `pnpm prefetch` and committed to the repository).
+   *
+   * All paths in returned Issues are relative to `ctx.repositoryRoot`.
+   * 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 = [];
+    const absoluteFiles = ctx.targetFiles.map(
+      (f) => import_path.default.resolve(ctx.repositoryRoot, f)
+    );
+    if (absoluteFiles.length === 0) {
+      const completedAt2 = /* @__PURE__ */ new Date();
+      return buildResult(startedAt, completedAt2, issues, errors, ctx.targetFiles.length);
+    }
+    let lintFn;
+    let readConfigFn;
+    try {
+      const mod = await importMarkdownlintSync();
+      lintFn = mod.lint;
+      readConfigFn = mod.readConfig;
+    } catch (err) {
+      const completedAt2 = /* @__PURE__ */ new Date();
+      errors.push({
+        toolId: TOOL_ID,
+        phase: "toolInvoke",
+        kind: "InvocationError",
+        message: `Failed to load markdownlint: ${err instanceof Error ? err.message : String(err)}`,
+        level: "error"
+      });
+      return buildResult(startedAt, completedAt2, issues, errors, ctx.targetFiles.length);
+    }
+    let inlineConfig;
+    if (codacyConfig.useLocalConfigurationFile && codacyConfig.localConfigurationFile) {
+      try {
+        inlineConfig = readConfigFn(codacyConfig.localConfigurationFile);
+      } catch (err) {
+        errors.push({
+          toolId: TOOL_ID,
+          phase: "toolConfig",
+          kind: "ConfigReadError",
+          message: `Failed to read config file ${codacyConfig.localConfigurationFile}: ${err instanceof Error ? err.message : String(err)}`,
+          level: "warning"
+        });
+      }
+    } else if (codacyConfig.patterns.length > 0) {
+      inlineConfig = buildMarkdownlintConfig(codacyConfig.patterns);
+    }
+    const lintOptions = { files: absoluteFiles };
+    if (inlineConfig !== void 0) {
+      lintOptions.config = inlineConfig;
+    }
+    try {
+      const lintResults = lintFn(lintOptions);
+      for (const [filePath, lintErrors] of Object.entries(lintResults)) {
+        const relPath = import_path.default.relative(ctx.repositoryRoot, filePath);
+        for (const lintError of lintErrors) {
+          const ruleId = lintError.ruleNames[0];
+          if (!ruleId) {
+            errors.push({
+              toolId: TOOL_ID,
+              phase: "outputParse",
+              kind: "UnknownPattern",
+              message: `markdownlint returned an issue with no rule name in file: ${relPath}`,
+              level: "warning",
+              filePath: relPath
+            });
+            continue;
+          }
+          const line = lintError.lineNumber;
+          const column = lintError.errorRange ? lintError.errorRange[0] : 1;
+          const detail = lintError.errorDetail ? `: ${lintError.errorDetail}` : "";
+          const message = `${lintError.ruleDescription}${detail}`;
+          const meta = ruleMetadata(ruleId);
+          issues.push({
+            filePath: relPath,
+            patternId: `${TOOL_ID}_${ruleId}`,
+            toolId: TOOL_ID,
+            line,
+            column,
+            message,
+            lineContent: readLine(filePath, line),
+            category: meta.category,
+            severity: meta.severity
+          });
+        }
+      }
+    } catch (err) {
+      errors.push({
+        toolId: TOOL_ID,
+        phase: "toolInvoke",
+        kind: "InvocationError",
+        message: `markdownlint failed: ${err instanceof Error ? err.message : String(err)}`,
+        level: "error"
+      });
+    }
+    const completedAt = /* @__PURE__ */ new Date();
+    ctx.logger.info("Analysis complete", { toolId: TOOL_ID, issueCount: issues.length, errorCount: errors.length, durationMs: Date.now() - startMs });
+    return buildResult(startedAt, completedAt, issues, errors, ctx.targetFiles.length);
+  }
+};
+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
+    }
+  };
+}
+
+// src/index.ts
+var index_default = (0, import_tooling.defineToolAdapter)(adapter);

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@codacy/tools-markdownlint-0",
+  "version": "0.1.0",
+  "description": "markdownlint adapter — Library-mode Markdown linter",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "markdownlint": "^0.37.4",
+    "@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/markdownlint-0"
+  },
+  "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 547ff16b-d57c-4d75-8067-5ccf3ea88a00 src/patterns.json"
+  }
+}