@hawkeyexl/manni 2.12.1 → 4.0.0

package/dist/index.js

@@ -1,11 +1,57 @@
 #!/usr/bin/env node
 import {
+  BLOCK_KINDS,
+  BUILTIN_SOURCE,
+  BUILT_IN_DEFAULTS,
   KeyError,
+  LINT_JOBS,
+  LINT_TOOLS,
+  LintError,
+  RULE_ID_PREFIX2 as RULE_ID_PREFIX,
+  STDIN_LABEL,
+  TOOLS_BY_JOB,
+  TOOL_NAME,
   cite_exports,
+  classifyRef as classifyRef2,
+  clearMatcherCache,
+  clearPatternCache,
+  clearTemplateCaches,
+  headingMatches,
+  isLintTool,
+  isWildcard,
+  listBuiltins as listBuiltins2,
+  listFormats,
+  loadConfig as loadConfig2,
+  loadTemplate,
+  loadTemplateFile,
+  matchSections,
+  occurrenceRange,
+  parseConfig as parseConfig2,
+  parserByName,
+  parserForExtension,
+  rebaseConfig,
   reencryptMetadata,
+  render as render2,
+  renderGithub,
+  renderJson,
+  renderJunit as renderJunit2,
+  renderPretty,
+  renderSarif as renderSarif2,
+  renderTemplates,
+  renderTools,
+  resolveExtends,
+  resolveLintRun,
+  ruleId,
+  ruleName,
   runKeyRotate,
-  runKeySet
-} from "./chunk-7X4QMQX4.js";
+  runKeySet,
+  runLint,
+  runTemplates,
+  runTools,
+  supportedExtensions as supportedExtensions2,
+  validateDocument,
+  validateSections
+} from "./chunk-YDUFTHBZ.js";
 import {
   BinMissing,
   COMMON_FORMATS,
@@ -29,6 +75,7 @@ import {
   GitLabClient,
   INTEGRITY_SHAPE,
   LOCATION_KEYWORD,
+  MERGE_SAFE_FIELDS,
   PATH_JOIN,
   PATH_PLACEHOLDER,
   QUERY_FORMATS,
@@ -39,6 +86,7 @@ import {
   ReviewCache,
   SCHEMA_CACHE_DIR,
   SCHEMA_CACHE_VERSION,
+  STDIN_TOKEN,
   SchemaCache,
   Validator,
   __export,
@@ -91,6 +139,7 @@ import {
   orphanEntries,
   orphanError,
   orphanJoins,
+  palette,
   parseCollections,
   parseConfig,
   parseOriginUrl,
@@ -120,6 +169,7 @@ import {
   schemaEntryRef,
   schemaLoadOptions,
   selectCollections,
+  shouldColor,
   sourcesFor,
   staleFindings,
   stringifyValue,
@@ -127,7 +177,64 @@ import {
   valueOf,
   vendorFileName,
   writeFileAtomic
-} from "./chunk-F6CE4LEJ.js";
+} from "./chunk-O7RMPQZ4.js";
+
+// src/lint/index.ts
+var lint_exports = {};
+__export(lint_exports, {
+  BLOCK_KINDS: () => BLOCK_KINDS,
+  BUILTIN_SOURCE: () => BUILTIN_SOURCE,
+  BUILT_IN_DEFAULTS: () => BUILT_IN_DEFAULTS,
+  LINT_JOBS: () => LINT_JOBS,
+  LINT_TOOLS: () => LINT_TOOLS,
+  LintError: () => LintError,
+  RULE_ID_PREFIX: () => RULE_ID_PREFIX,
+  STDIN_LABEL: () => STDIN_LABEL,
+  STDIN_TOKEN: () => STDIN_TOKEN,
+  TOOLS_BY_JOB: () => TOOLS_BY_JOB,
+  TOOL_NAME: () => TOOL_NAME,
+  classifyRef: () => classifyRef2,
+  clearCaches: () => clearCaches,
+  headingMatches: () => headingMatches,
+  isLintTool: () => isLintTool,
+  isWildcard: () => isWildcard,
+  listBuiltins: () => listBuiltins2,
+  listFormats: () => listFormats,
+  loadConfig: () => loadConfig2,
+  loadTemplate: () => loadTemplate,
+  loadTemplateFile: () => loadTemplateFile,
+  matchSections: () => matchSections,
+  occurrenceRange: () => occurrenceRange,
+  palette: () => palette,
+  parseConfig: () => parseConfig2,
+  parserByName: () => parserByName,
+  parserForExtension: () => parserForExtension,
+  rebaseConfig: () => rebaseConfig,
+  render: () => render2,
+  renderGithub: () => renderGithub,
+  renderJson: () => renderJson,
+  renderJunit: () => renderJunit2,
+  renderPretty: () => renderPretty,
+  renderSarif: () => renderSarif2,
+  renderTemplates: () => renderTemplates,
+  renderTools: () => renderTools,
+  resolveExtends: () => resolveExtends,
+  resolveLintRun: () => resolveLintRun,
+  ruleId: () => ruleId,
+  ruleName: () => ruleName,
+  runLint: () => runLint,
+  runTemplates: () => runTemplates,
+  runTools: () => runTools,
+  shouldColor: () => shouldColor,
+  supportedExtensions: () => supportedExtensions2,
+  validateDocument: () => validateDocument,
+  validateSections: () => validateSections
+});
+function clearCaches() {
+  clearTemplateCaches();
+  clearMatcherCache();
+  clearPatternCache();
+}
 
 // src/key/index.ts
 var key_exports = {};
@@ -163,6 +270,7 @@ export {
   GitLabClient,
   INTEGRITY_SHAPE,
   LOCATION_KEYWORD,
+  MERGE_SAFE_FIELDS,
   PATH_JOIN,
   PATH_PLACEHOLDER,
   QUERY_FORMATS,
@@ -212,6 +320,7 @@ export {
   isQueryFormat,
   isReportFormat,
   key_exports as key,
+  lint_exports as lint,
   listBuiltins,
   loadConfig,
   loadExternalMetadata,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/key/index.ts"],"sourcesContent":["/**\n * The key domain's programmatic API, exported from the package as the `key`\n * namespace: `import { key } from \"@hawkeyexl/manni\"`. The command cores, and\n * the family's encryption primitives a caller needs beside them.\n */\nexport * from \"./types.js\";\nexport { KeyError } from \"./errors.js\";\nexport { runKeySet } from \"./commands/set.js\";\nexport { runKeyRotate } from \"./commands/rotate.js\";\nexport { decryptValue, encryptValue, isEncryptedValue } from \"../shared/encryption.js\";\nexport type { EncryptionContext } from \"../shared/encryption.js\";\nexport { resolveEncryptionKey } from \"../shared/encryption-key.js\";\nexport type { KeySource, ResolvedKey } from \"../shared/encryption-key.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;","names":[]}
+{"version":3,"sources":["../src/lint/index.ts","../src/key/index.ts"],"sourcesContent":["/** Programmatic API for manni lint. */\nimport { clearTemplateCaches } from \"./core/template-registry.js\";\nimport { clearMatcherCache } from \"./core/resolve-template.js\";\nimport { clearPatternCache } from \"./rules/index.js\";\n\n/**\n * Drop every process-lifetime cache: parsed built-ins, fetched template files,\n * compiled override globs, and compiled heading patterns.\n *\n * A CLI run never needs this - it lints one docset and exits, and the caches\n * are what stop a tree of one doctype from re-reading the same template per\n * page. A long-lived host is the different case: the maps grow with the number\n * of distinct refs and patterns seen, and a cached remote template is served\n * for the life of the process, so one republished upstream is never picked up.\n * Call this between runs, or when a template may have changed underneath.\n */\nexport function clearCaches(): void {\n  clearTemplateCaches();\n  clearMatcherCache();\n  clearPatternCache();\n}\n\nexport { runLint, STDIN_LABEL } from \"./commands/lint.js\";\nexport type {\n  LintOptions,\n  LintRun,\n  LintSummary,\n  LintFileResult,\n} from \"./commands/lint.js\";\nexport { runTemplates, BUILTIN_SOURCE } from \"./commands/templates.js\";\nexport type {\n  TemplateInfo,\n  TemplatesInfo,\n  TemplatesOptions,\n} from \"./commands/templates.js\";\nexport { runTools, BUILT_IN_DEFAULTS } from \"./commands/tools.js\";\nexport type { FormatInfo, ToolInfo, ToolsOptions } from \"./commands/tools.js\";\nexport {\n  LINT_JOBS,\n  LINT_TOOLS,\n  TOOLS_BY_JOB,\n  isLintTool,\n  loadConfig,\n  parseConfig,\n  rebaseConfig,\n  resolveLintRun,\n} from \"./core/config.js\";\nexport type {\n  LintConfig,\n  LintJob,\n  LintJobConfig,\n  LintRunOptions,\n  LintTool,\n  ResolvedLintRun,\n} from \"./core/config.js\";\nexport { validateDocument, validateSections } from \"./core/validator.js\";\nexport { matchSections } from \"./core/match.js\";\nexport type { Match, MatchResult } from \"./core/match.js\";\nexport {\n  BLOCK_KINDS,\n  headingMatches,\n  isWildcard,\n  occurrenceRange,\n} from \"./core/template.js\";\nexport type {\n  AdmonitionsRule,\n  AttributesRule,\n  BlockKind,\n  BlockRule,\n  CodeBlocksRule,\n  ElementsRule,\n  HeadingRule,\n  ImagesRule,\n  ListItemsRule,\n  ListsRule,\n  Occurrences,\n  ParagraphsRule,\n  Rule,\n  TablesRule,\n  Template,\n  TemplateFile,\n} from \"./core/template.js\";\nexport {\n  listBuiltins,\n  loadTemplate,\n  loadTemplateFile,\n  resolveExtends,\n  classifyRef,\n} from \"./core/template-registry.js\";\nexport type {\n  BuiltinInfo,\n  LoadTemplateOptions,\n  RefKind,\n  TemplateResolver,\n} from \"./core/template-registry.js\";\n// Targets resolve through the family's walker (`src/meta/internal.ts`), which\n// is what makes `--ext`, `--exclude`, `.gitignore` handling and `--allow-empty`\n// mean the same thing here as they do for `meta` and `cite`.\nexport { STDIN_TOKEN } from \"../meta/internal.js\";\nexport {\n  listFormats,\n  parserByName,\n  parserForExtension,\n  supportedExtensions,\n} from \"./parsers/index.js\";\nexport {\n  render,\n  renderPretty,\n  renderJson,\n  renderGithub,\n  renderJunit,\n  renderTemplates,\n  renderTools,\n} from \"./reporters/index.js\";\nexport type {\n  ReportFormat,\n  ReportOptions,\n  ListFormat,\n} from \"./reporters/index.js\";\nexport { renderSarif } from \"./reporters/sarif.js\";\nexport type { SarifOptions } from \"./reporters/sarif.js\";\n// A finding's durable identity, so a caller filing or correlating findings\n// spells the id the same way every reporter does.\nexport { RULE_ID_PREFIX, TOOL_NAME, ruleId, ruleName } from \"./core/rule-id.js\";\n// Colour is the family's decision, made once in `src/shared/color.js`. These\n// are re-exported here so a library caller building lint's reports does not\n// have to reach for another tool's entry point to turn ANSI on or off.\nexport { palette, shouldColor } from \"../shared/color.js\";\nexport * from \"./types.js\";\n","/**\n * The key domain's programmatic API, exported from the package as the `key`\n * namespace: `import { key } from \"@hawkeyexl/manni\"`. The command cores, and\n * the family's encryption primitives a caller needs beside them.\n */\nexport * from \"./types.js\";\nexport { KeyError } from \"./errors.js\";\nexport { runKeySet } from \"./commands/set.js\";\nexport { runKeyRotate } from \"./commands/rotate.js\";\nexport { decryptValue, encryptValue, isEncryptedValue } from \"../shared/encryption.js\";\nexport type { EncryptionContext } from \"../shared/encryption.js\";\nexport { resolveEncryptionKey } from \"../shared/encryption-key.js\";\nexport type { KeySource, ResolvedKey } from \"../shared/encryption-key.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAAAA;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA,sBAAAC;AAAA,EAAA;AAAA,oBAAAC;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAAAC;AAAA,EAAA;AAAA;AAAA;AAAA,gBAAAC;AAAA,EAAA;AAAA;AAAA,qBAAAC;AAAA,EAAA;AAAA,qBAAAC;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,6BAAAC;AAAA,EAAA;AAAA;AAAA;AAgBO,SAAS,cAAoB;AAClC,sBAAoB;AACpB,oBAAkB;AAClB,oBAAkB;AACpB;;;ACpBA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;","names":["classifyRef","listBuiltins","loadConfig","parseConfig","render","renderJunit","renderSarif","supportedExtensions"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hawkeyexl/manni",
-  "version": "2.12.1",
+  "version": "4.0.0",
   "description": "One command line for documentation that is meant to be checked. `manni meta` validates the presence and format of document metadata (Markdown frontmatter and more) against JSON Schema, built for CI. Formerly docmeta.",
   "type": "module",
   "bin": {
@@ -18,7 +18,9 @@
     "./package.json": "./package.json"
   },
   "files": [
-    "dist"
+    "dist",
+    "schemas",
+    "templates"
   ],
   "repository": {
     "type": "git",
@@ -47,6 +49,8 @@
     "lint": "eslint .",
     "check:deps": "node scripts/check-deps.mjs",
     "query:ui": "npm run build && node dist/cli.js meta query --db .manni/meta/query.db && node scripts/query-ui.mjs .manni/meta/query.db",
+    "check:tgdp-pin": "node scripts/lint-check-tgdp-pin.mjs",
+    "smoke:lint": "npm run build && node scripts/lint-smoke.mjs",
     "docs:check-cli": "node scripts/check-cli-reference.mjs",
     "docs:check-action": "node scripts/check-action-reference.mjs",
     "docs:check-api": "node scripts/check-api-reference.mjs",
@@ -77,8 +81,10 @@
     "esbuild": "^0.28.2"
   },
   "dependencies": {
+    "@apidevtools/json-schema-ref-parser": "^11.9.3",
+    "@asciidoctor/core": "^3.0.4",
     "@axe-core/playwright": "^4.13.0",
-    "@hawkeyexl/inference": "^0.3.1",
+    "@hawkeyexl/inference": "^0.3.2",
     "@xmldom/xmldom": "^0.9.12",
     "ajv": "^8.17.1",
     "ajv-draft-04": "^1.0.0",
@@ -86,11 +92,18 @@
     "commander": "^15.0.0",
     "fast-glob": "^3.3.2",
     "github-slugger": "^2.0.0",
+    "mdast-util-to-string": "^4.0.0",
     "parse5": "^8.0.1",
     "picocolors": "^1.1.1",
     "picomatch": "^4.0.7",
     "playwright-core": "^1.63.0",
+    "remark-frontmatter": "^5.0.0",
+    "remark-gfm": "^4.0.1",
+    "remark-mdx": "^3.1.1",
+    "remark-parse": "^11.0.0",
     "smol-toml": "^1.8.0",
+    "unified": "^11.0.5",
+    "unist-util-visit": "^5.1.0",
     "yaml": "^2.6.1"
   },
   "devDependencies": {
@@ -103,8 +116,10 @@
     "@semantic-release/github": "^12.0.8",
     "@semantic-release/npm": "^13.1.5",
     "@semantic-release/release-notes-generator": "^14.1.1",
+    "@types/mdast": "^4.0.4",
     "@types/node": "^26.3.0",
     "@types/picomatch": "^4.0.3",
+    "@types/unist": "^3.0.3",
     "@vitest/coverage-v8": "^4.1.11",
     "eslint": "^10.9.1",
     "globals": "^17.11.0",

package/schemas/lint/config.json

@@ -0,0 +1,73 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "manni-lint:config:1",
+  "title": "manni lint config section",
+  "description": "The `lint:` section of a shared `manni.config.yaml`. The file's root is a mapping of tool name to that tool's settings, so this schema describes the section only - never the file. The document set is not here: proposal 0041 declares it once for every tool, under the family-level `collections:` key, and `paths`/`exclude` under `lint:` are refused by name. Every key is optional: a repo that configures no manni lint at all is a legitimate config, and so is one that carries only a sibling tool's section. `additionalProperties: false` applies at every level below `lint:`, which is what turns a typo'd key into a loud failure instead of a silent default.",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "allowEmpty": {
+      "description": "Treat a run that matched zero files as a success rather than an operational error. The same key, with the same meaning, as `cite.allowEmpty`: for a shared CI template or a pre-commit hook whose file list may legitimately be empty. `--allow-empty` on the command line sets it for one run.",
+      "type": "boolean"
+    },
+    "overrides": {
+      "description": "Repo policy: everything under a glob is linted with one template, whatever the pages say they are. First matching entry wins, and an override outranks a page's own `type`.",
+      "type": "array",
+      "items": {
+        "description": "One policy entry. Both keys are required: an entry naming no template, or no files, is a line that silently does nothing.",
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["files", "template"],
+        "properties": {
+          "files": {
+            "description": "Glob matched against each file's path, written with forward slashes whatever the platform uses.",
+            "type": "string",
+            "minLength": 1
+          },
+          "template": {
+            "description": "Template ref applied to the files this entry matches.",
+            "type": "string",
+            "minLength": 1
+          }
+        }
+      }
+    },
+    "structure": {
+      "description": "The structure job, which `manni lint structure` and `manni lint check` both run. Declaring it with no keys is how a repo says the job applies. Its one setting is the tool that performs it.",
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "tool": {
+          "description": "Which tool performs the job. `manni` is manni's own template-structure engine; `dita-ot` is DITA Open Toolkit, which validates a DITA map and the topics it reaches and is located through the top-level `tools.dita-ot.home`. `--tool <name>` on the command line names the same thing.",
+          "type": "string",
+          "enum": ["manni", "dita-ot"]
+        }
+      }
+    },
+    "template": {
+      "description": "Template ref applied to a page that declares no doctype and matches no override. The last stage of the resolution chain, not an override: `--template`, a page's `$template`, an `overrides` entry, and the page's own `type` all outrank it.",
+      "type": "string",
+      "minLength": 1
+    },
+    "templates": {
+      "description": "Template files to load. Their templates' `types:` join the doctype routing table, outranking the built-ins, so adopting a repo's own how-to shape is one entry here and no flag.",
+      "type": "array",
+      "items": {
+        "type": "string",
+        "minLength": 1
+      }
+    },
+    "types": {
+      "description": "Explicit doctype -> template ref map, for a doctype no template file claims with its own `types:`. Keys are the vocabulary a page's `type` frontmatter is written in, so they are the author's names rather than this schema's - constrained only to the shape a doctype slug takes, not to a fixed set.",
+      "type": "object",
+      "additionalProperties": false,
+      "patternProperties": {
+        "^[A-Za-z0-9._:-]+$": {
+          "description": "A template ref: a built-in id, a path, or a URL, optionally with a `#name` fragment.",
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    }
+  }
+}