@heroiclands/package-build 22.9.1 → 22.10.0

package/engine/wikilinks.mjs

@@ -82,15 +82,30 @@
  * Plain ESM with no Foundry and no filesystem access, so it is unit-testable.
  */
 
+import { resolveShortcodeReference } from "./shortcode-references.mjs";
+
+import { readWikilink } from "./wikilink-syntax.mjs";
 import crypto from "crypto";
 
 import { compendiumUuid, ITEM_PACK, packForType, pageUuid, PACK_BY_TYPE } from "./ids.mjs";
 import { readCanonicalKey } from "./content-address.mjs";
+// The address grammar. A wikilink *contains* an Address, so what counts as one
+// is stated there and read here — the anchor and the label are this module's,
+// and the tuple inside them is not.
+import {
+    ITEM_DOC_PREFIX,
+    readQualifier,
+    resolveItemDocType,
+    parseAddress,
+    renderAddress,
+    isAddressTuple,
+    completeAddress,
+} from "./address.mjs";
 import { ASSET_TYPE_NAMES } from "./asset-types.mjs";
-import { isSystemSegment, NO_SYSTEM } from "./systems.mjs";
+import { NO_SYSTEM } from "./systems.mjs";
 import { systemOf } from "./document-subtypes.mjs";
 import { KNOWN_DOCUMENT_SUBTYPE_MAPS } from "./subtype-registry.mjs";
-import { hasDocEntry, itemDocEntryId } from "./item-docs.mjs";
+import { itemDocEntryId } from "./item-docs.mjs";
 import { replaceOutsideCode } from "./code-fences.mjs";
 // The syntax lives in `./wikilink-syntax.mjs`, so the web resolver and this
 // one cannot disagree about what counts as a link.
@@ -104,227 +119,14 @@ import {
 export { ITEM_PACK, PACK_BY_TYPE, packForType };
 
 /**
- * The qualifier prefix that addresses an item's **documentation** rather than
- * the item: `docskill/wpnc` is the JournalEntry that `skill/wpnc`'s prose
- * compiled into. See {@link resolveItemDocType}.
- */
-const ITEM_DOC_PREFIX = "doc";
-
-const norm = (s) => String(s).toLowerCase().trim();
-
-/**
- * Reads a qualifier as the **virtual `doc<type>`** form, or reports that it is
- * not one.
- *
- * A document and its documentation are two documents in two packs, so they
- * need two addresses. `skill/wpnc` is the item; `docskill/wpnc` is the
- * JournalEntry its prose compiled into, and `docmacro/autoattack` is the same
- * arrangement for a macro.
- *
- * The virtual form exists for a type that carries separate documentation
- * ({@link sohl.utils.packs.docEntryTypes} — the set the journals compiler and
- * the link manifest read too), **or** for one that routes to the items pack.
- * The second clause is the older rule and stays: types that compile into items
- * are the open, unenumerated set, and a foreign package may publish an
- * item type this build has never heard of. Dropping it would silently unlink
- * every `doc<type>` address into such a package.
- *
- * A **real** type of the same name always wins: the virtual reading is only
- * consulted for a qualifier no authored note claims.
- *
- * @param {string} qualifier - The already-normalised text before the `/`.
- * @param {Set<string>} types - Every type the content tree contains.
- * @returns {string|null} The underlying document type, or `null` when the
- *   qualifier is not a virtual one.
- */
-export function resolveItemDocType(qualifier, types) {
-    if (types.has(qualifier)) return null; // a real type owns its own name
-    if (!qualifier.startsWith(ITEM_DOC_PREFIX)) return null;
-    const base = qualifier.slice(ITEM_DOC_PREFIX.length);
-    if (!base || !types.has(base)) return null;
-    if (hasDocEntry(base)) return base;
-    return packForType(base).docType === ITEM_PACK.docType ? base : null;
-}
-
-/**
- * Read a link target as a **qualified** `type-shortcode` reference, or report
- * that it does not parse as one.
- *
- * Two separators are accepted, and they are **not** interchangeable in how
- * confidently they mark a target as qualified:
- *
- * - **`type-shortcode`** and its qualified forms — the canonical spelling.
- * Obsidian reads `/` inside a wikilink as a *path* and resolves it
- *   against the vault's folders, so a slash-qualified link is a broken link in
- *   the editor where the content is now authored.
- * - **`type/shortcode`** — the legacy form, still resolved so that a link
- *   written before the vault migrated does not silently die. A slash is
- *   *unconditionally* a qualifier: nothing else uses one, so an unknown type
- *   before it is reported rather than guessed at. The split is at the **last**
- *   slash, as it always was.
- *
- * **The grammar is strict, and omission runs left to right**:
- *
- * ```text
- * [[[[<package>-]<system>-]<type>-]<shortcode>]
- * ```
- *
- * So the written forms are exactly the suffixes of the canonical address —
- * `type-shortcode`, `system-type-shortcode`, `package-system-type-shortcode` —
- * and **`package-type-shortcode` is not one of them**. A link into another
- * package must therefore be fully qualified, which is the price of the segment
- * being positional rather than tagged.
- *
- * **Parsing is plain positional counting**, the same rule
- * {@link readCanonicalKey} follows, and it is sound for the same reason: every
- * segment matches `ADDRESS_SEGMENT_PATTERN` (enforced on shortcodes by
- * `content-lint.mjs`), so the hyphen is purely a
- * separator and the count alone determines every field. Verified across the
- * four content trees: 138,204 authored shortcodes, none carrying a separator.
- *
- * That replaced a first-hyphen split which let a shortcode contain a hyphen
- * (`trauma-self-pro` → `trauma` + `self-pro`). The tolerance predates the
- * charset rule and
- * outlived it; no tree has used it, and keeping it would make a three-segment
- * target ambiguous between a system and a hyphenated shortcode.
- *
- * **`sohl` is both a package and a system**, and positional counting is what
- * makes that harmless: three segments is `<system>-<type>-<shortcode>` whatever
- * the first segment could also have named, and four is the full form. Nothing
- * has to guess which sense was meant.
- *
- * **A partial address states what it states, and the rest is not invented.** An
- * omitted **system** is a *wildcard* — most links target items, which belong to
- * a system — so the caller matches on the segments supplied and requires
- * exactly one hit. An omitted **package** is instead *defaulted* to the citing
- * note's own, so an unqualified link resolves locally and only locally.
- *
- * @param {string} target - The link target, anchor already removed.
- * @param {Set<string>} types - Every type the content tree contains.
- * @param {Set<string>} [packages] - Every package an address may name. Omitted
- *   by callers that resolve within one package, where the form cannot occur.
- * @param {Set<string>} [noIndexPackages] - Packages declared `contentIndex:
- *   false` — a Foundry dependency only, with no fetched index. A fully
- *   qualified target naming one is refused with `no-content-index` before its
- *   type is even considered, since there is no index to resolve it against.
- * @returns {{type: string, shortcode: string, itemDoc: boolean,
- *   package?: string, system?: string, reason?: undefined}
- *   | {reason: "unknown-type"|"no-content-index", package?: string} | null}
- *   The resolved qualifier; a `reason` when the target is definitely qualified
- *   but names no known type or no fetched index; or `null` when it is not an
- *   address at all.
- */
-export function readQualifier(target, types, packages, noIndexPackages) {
-    // **Package, system and type are lowercase; the shortcode is not.** A
-    // shortcode is case-sensitive and routinely mixed — `Clb`, `LtShoe`,
-    // `HsTunic` — so it is written as the note declares it. The three segments
-    // in front of it are closed vocabularies with one spelling each, and
-    // accepting `Skill` beside `skill` would bless two ways of writing one
-    // address. Reported rather than folded, so the corpus has one form.
-    //
-    // Tested only once the target *parses*: a note name is full of capitals
-    // (`[[Shock State]]`), and calling that a badly-cased address rather than
-    // not an address would name the wrong mistake. Neither tree carries a
-    // violation — 10,538 authored targets — so this pins a rule already kept.
-    const read = readQualifierCased(target, types, packages, noIndexPackages);
-    if (read && !read.reason && qualifyingSegments(target).some((s) => /[A-Z]/.test(s))) {
-        return { reason: "not-lowercase" };
-    }
-    return read;
-}
-
-/**
- * The segments of a target that must be lowercase — everything but the
- * shortcode, which is case-sensitive and keeps whatever the note declares.
- *
- * @param {string} target - The link target, anchor already removed.
- * @returns {string[]} The package / system / type segments, as written.
- */
-function qualifyingSegments(target) {
-    const slash = target.lastIndexOf("/");
-    // The legacy `type/shortcode` form states only a type.
-    if (slash > 0) return [target.slice(0, slash)];
-    const parts = target.split("-");
-    return parts.slice(0, -1);
-}
-
-/**
- * {@link readQualifier} without the lowercase rule — the grammar alone.
+ * The address grammar, under the names the link resolvers hold it by.
  *
- * @param {string} target
- * @param {Set<string>} types
- * @param {Set<string>} [packages]
- * @param {Set<string>} [noIndexPackages]
- * @returns {object|null}
+ * {@link readQualifier} reads a link target as the partial Address the matchers
+ * consume, and {@link resolveItemDocType} is the `doc<type>` reading it applies.
  */
-function readQualifierCased(target, types, packages, noIndexPackages) {
-    // The slash form is legacy and states neither package nor system, so it is
-    // read first and separately. A slash is unconditionally a qualifier —
-    // nothing else uses one — which is why an unknown type before it is
-    // *reported* rather than read as prose.
-    const slash = target.lastIndexOf("/");
-    if (slash > 0) {
-        const read = readTypeAndCode(target.slice(0, slash), target.slice(slash + 1), types);
-        return read ?? { reason: "unknown-type" };
-    }
-
-    const parts = target.split("-");
-    switch (parts.length) {
-        // `<type>-<shortcode>`
-        case 2:
-            return readTypeAndCode(parts[0], parts[1], types);
-
-        // `<system>-<type>-<shortcode>` — the package defaults to local.
-        case 3: {
-            const system = norm(parts[0]);
-            if (!isSystemSegment(system)) return null;
-            const read = readTypeAndCode(parts[1], parts[2], types);
-            return read && { ...read, system };
-        }
-
-        // `<package>-<system>-<type>-<shortcode>` — the only form that names
-        // another package, and the reason a cross-package link must be fully
-        // qualified.
-        case 4: {
-            const pkg = norm(parts[0]);
-            // Checked before the type: a package with no fetched index has no
-            // vocabulary to resolve the rest of the target against, and the
-            // fix is the config declaration, not the shortcode.
-            if (noIndexPackages?.has(pkg)) return { reason: "no-content-index", package: pkg };
-            if (!packages?.has(pkg)) return null;
-            const system = norm(parts[1]);
-            if (!isSystemSegment(system)) return null;
-            const read = readTypeAndCode(parts[2], parts[3], types);
-            return read && { ...read, system, package: pkg };
-        }
-
-        // One segment is a bare name, which is not an address; five or
-        // more is not a hyphenated shortcode but a name that happens to carry
-        // separators, since no segment may contain one.
-        default:
-            return null;
-    }
-}
+export { readQualifier, resolveItemDocType };
 
-/**
- * Resolve a qualifier/shortcode pair, honouring the virtual `doc<type>` form.
- *
- * @param {string} rawType
- * @param {string} rawCode
- * @param {Set<string>} types
- * @returns {{type: string, shortcode: string, itemDoc: boolean} | null}
- *   `null` when the qualifier names no known type, or the shortcode is empty.
- */
-function readTypeAndCode(rawType, rawCode, types) {
-    const shortcode = norm(rawCode);
-    if (!shortcode) return null;
-
-    let type = norm(rawType);
-    const base = resolveItemDocType(type, types);
-    if (base) return { type: base, shortcode, itemDoc: true };
-    if (!types.has(type)) return null;
-    return { type, shortcode, itemDoc: false };
-}
+const norm = (s) => String(s).toLowerCase().trim();
 
 /**
  * The deterministic JournalEntryPage id for one anchor: SHA-256 of
@@ -384,7 +186,7 @@ export function buildWikilinkIndex(
     packageId,
     foreign,
     contentPackage,
-    { assets, noIndexPackages } = {},
+    { assets, noIndexPackages, referenceTargets, foreignReferences } = {},
 ) {
     if (!packageId) {
         throw new Error(
@@ -479,6 +281,8 @@ export function buildWikilinkIndex(
 
     return {
         byShortcode,
+        referenceTargets,
+        foreignReferences,
         types,
         uuidByDoc,
         packageId,
@@ -654,8 +458,14 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index }) {
     // one capture group. It is what makes two identical unresolved links on
     // one note tellable apart, and a position reportable at all.
     const out = replaceOutsideCode(markdown, WIKILINK, (all, rawInner, offset) => {
-        const parsed = parseWikilink(rawInner);
-        const target = parsed.target;
+        const parsed = readWikilink(rawInner, {
+            package: index.contentPackage,
+            system: "none",
+            types: index.types,
+            packages: index.packages,
+            noIndexPackages: index.noIndexPackages,
+        });
+        const target = parsed.rawTarget;
         const slug = parsed.anchor || null;
 
         // **Every link carries a label**. Without one there is nothing
@@ -692,12 +502,7 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index }) {
         if (target === "" && slug) {
             doc = { type, id, pack, docPack };
         } else {
-            const qualified = readQualifier(
-                target,
-                index.types,
-                index.packages,
-                index.noIndexPackages,
-            );
+            const qualified = parsed.problem ?? parsed.target;
             qualifiedRead = qualified;
             // A target that does not parse as an address is a defect: there is
             // no second namespace left to fall through to.
@@ -723,11 +528,10 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index }) {
             // their own documents are core ones already at `none`, so
             // `macro-autoattack` names the Macro and `docmacro-autoattack` its
             // journal — two live addresses the redirect would collapse.
-            itemDoc =
-                qualified.itemDoc ||
-                ((qualified.system ?? NO_SYSTEM) === NO_SYSTEM &&
-                    systemOf(qualified.type, KNOWN_DOCUMENT_SUBTYPE_MAPS) !== NO_SYSTEM);
-            doc = index.byShortcode.get(`${qualified.type}/${qualified.shortcode}`);
+            const baseType = resolveItemDocType(qualified.type, index.types);
+            itemDoc = Boolean(baseType);
+            if (qualified.package === index.contentPackage)
+                doc = index.byShortcode.get(`${baseType ?? qualified.type}/${qualified.shortcode}`);
         }
         if (!doc) {
             // Nothing local answers. A foreign package may publish this
@@ -843,42 +647,6 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index }) {
     return { markdown: out, unresolved };
 }
 
-/**
- * The short `type/shortcode` view of an index's foreign entries.
- *
- * Derived once per index and memoised: a compile resolves references on every
- * one of thousands of notes, and rebuilding the view per note would rescan a
- * dependency's whole published index each time. Keyed on the index object, so
- * it is discarded with it.
- *
- * An address two foreign packages both claim is left out rather than resolved
- * to whichever loaded first — the same rule the wikilink resolver follows.
- *
- * @type {WeakMap<object, Map<string, object>>}
- */
-const FOREIGN_BY_SHORTCODE = new WeakMap();
-
-/** The memoised short view of `index.foreign`. */
-function foreignByShortcode(index) {
-    const cached = FOREIGN_BY_SHORTCODE.get(index);
-    if (cached) return cached;
-    const short = new Map();
-    const ambiguous = new Set();
-    for (const [key, value] of index?.foreign ?? []) {
-        const parts = readCanonicalKey(key);
-        if (!parts) continue;
-        const shortKey = `${norm(parts.type)}/${norm(parts.shortcode)}`;
-        if (short.has(shortKey) && short.get(shortKey).package !== value.package) {
-            ambiguous.add(shortKey);
-        } else {
-            short.set(shortKey, value);
-        }
-    }
-    for (const key of ambiguous) short.delete(key);
-    FOREIGN_BY_SHORTCODE.set(index, short);
-    return short;
-}
-
 /**
  * Resolve one reference against a compile's address index.
  *
@@ -892,46 +660,64 @@ function foreignByShortcode(index) {
  * @param {object} index - From {@link buildWikilinkIndex}.
  * @param {unknown} ref - The reference, as authored.
  * @param {object} [hint] - `{type}`, where the caller knows what it expects.
- * @returns {{name?: string, uuid?: string, address?: string, subType?: string}|undefined}
+ * @returns {{name?: string, uuid?: string, address?: import("./address.mjs").AddressTuple, subType?: string}|undefined}
  *   The target, or `undefined` where nothing answers.
  */
 export function resolveReference(index, ref, hint) {
-    if (typeof ref !== "string" || !ref) return undefined;
-    const wanted = norm(ref);
-    const keys = [];
-    if (hint?.type) keys.push(`${norm(hint.type)}/${wanted}`);
-    if (wanted.includes("-")) {
-        const segments = wanted.split("-");
-        if (segments.length >= 2) {
-            keys.push(`${segments[segments.length - 2]}/${segments[segments.length - 1]}`);
-        }
-    }
-    if (!hint?.type) {
-        for (const type of [...(index?.types ?? [])].sort()) keys.push(`${type}/${wanted}`);
-    }
-
-    const foreign = foreignByShortcode(index);
-    for (const key of keys) {
-        const local = index?.byShortcode?.get(key);
-        if (local) {
-            return {
-                ...(local.name ? { name: local.name } : {}),
-                ...(local.subType ? { subType: local.subType } : {}),
-                ...(index.uuidByDoc?.get(local)?.uuid ?
-                    { uuid: index.uuidByDoc.get(local).uuid }
-                :   {}),
-                address: key.replace("/", "-"),
-            };
-        }
-        const away = foreign.get(key);
-        if (away) {
-            return {
-                ...(away.name ? { name: away.name } : {}),
-                ...(away.uuid ? { uuid: away.uuid } : {}),
-                ...(away.subType ? { subType: away.subType } : {}),
-                address: key.replace("/", "-"),
-            };
+    if (hint?.kind === "shortcode")
+        return resolveShortcodeReference(
+            [index.referenceTargets, index.foreignReferences ?? index.foreign],
+            ref,
+            hint,
+        );
+    const tuple = parseAddress(ref, {
+        package: index.contentPackage,
+        system: "none",
+        types: index.types,
+        packages: index.packages,
+        noIndexPackages: index.noIndexPackages,
+        type: hint?.type,
+    });
+    if (tuple.reason) return undefined;
+    const key = renderAddress(tuple);
+    const published =
+        index.referenceTargets?.get(key) ??
+        index.foreignReferences?.get(key) ??
+        index.foreign?.get(key);
+    if (published)
+        return {
+            name: published.name,
+            subType: published.subType,
+            ...(published.uuid ? { uuid: published.uuid } : {}),
+            address: tuple,
+        };
+    if (index.referenceTargets) return undefined;
+    {
+        const key = renderAddress(tuple);
+        if (tuple.package !== index.contentPackage) {
+            const foreign = index.foreign?.get(key);
+            if (foreign) return { ...foreign, address: tuple };
+            return undefined;
         }
+        const base = resolveItemDocType(tuple.type, index.types);
+        const type = base ?? tuple.type;
+        if (tuple.system !== (base ? NO_SYSTEM : systemOf(type, KNOWN_DOCUMENT_SUBTYPE_MAPS)))
+            return undefined;
+        const local = index.byShortcode?.get(`${type}/${tuple.shortcode}`);
+        if (!local) return undefined;
+        const addresses = index.uuidByDoc?.get(local);
+        const uuid =
+            base ?
+                Object.hasOwn(local, "documentationUuid") ?
+                    local.documentationUuid
+                :   addresses?.docUuid
+            :   addresses?.uuid;
+        return {
+            name: local.name,
+            subType: local.subType,
+            ...(uuid ? { uuid } : {}),
+            address: tuple,
+        };
     }
     return undefined;
 }

package/githooks/attribution.mjs

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/** Bounded identities and standalone credit forms shared with the commit hooks. */
+export const identities = [
+    "Codex",
+    "ChatGPT",
+    "OpenAI",
+    "OpenAI Codex",
+    "OpenAI ChatGPT",
+    "Claude",
+    "Claude Code",
+    "Anthropic",
+    "GitHub Copilot",
+    "Gemini",
+    "Cursor",
+    "AI",
+    "AI assistant",
+    "an AI assistant",
+];
+export const phrases = ["Generated by", "Generated with", "Assisted by", "Written by"];
+export const mailboxes = [
+    "codex@openai.com",
+    "chatgpt@openai.com",
+    "noreply@openai.com",
+    "claude@anthropic.com",
+    "noreply@anthropic.com",
+];
+const identity = new RegExp(`^(?:${identities.join("|")})$`, "i");
+const signature = new RegExp(`^(?:${phrases.join("|")})\\s+(.+?)[.!]?$`, "i");
+
+/** Normalize decoration while keeping each character's original UTF-16 offset. */
+function normalize(line) {
+    let chars = Array.from({ length: line.length }, (_, offset) => ({
+        text: line[offset],
+        offset,
+    }));
+    const replace = (pattern, keep) => {
+        const text = chars.map((char) => char.text).join("");
+        const matches = [...text.matchAll(pattern)];
+        for (const match of matches.reverse()) {
+            const retained = keep(match);
+            chars.splice(
+                match.index,
+                match[0].length,
+                ...chars.slice(match.index + retained.start, match.index + retained.end),
+            );
+        }
+    };
+    replace(/\[([^\]]+)\]\([^\s)]*\)/g, (match) => ({ start: 1, end: 1 + match[1].length }));
+    replace(/[*_`~]/g, () => ({ start: 0, end: 0 }));
+    replace(/^[^\p{L}]+/gu, () => ({ start: 0, end: 0 }));
+    return {
+        text: chars
+            .map((char) => char.text)
+            .join("")
+            .trimEnd(),
+        column: (chars[0]?.offset ?? 0) + 1,
+    };
+}
+
+/** Find a complete credit clause; ordinary prose and human identities pass. */
+export function attribution(line) {
+    const normalized = normalize(line);
+    const trailer = normalized.text.match(/^co-authored-by:\s*(.*?)\s*(?:<([^<>]+)>)?$/i);
+    if (trailer && (identity.test(trailer[1]) || mailboxes.includes(trailer[2]?.toLowerCase()))) {
+        return { column: normalized.column, kind: "Co-Authored-By trailer naming an assistant" };
+    }
+    const credit = normalized.text.match(signature);
+    const generic = normalized.text.match(
+        /^AI-(?:assisted|generated)(?:\s+(?:by|with)\s+(.+?))?[.!]?$/i,
+    );
+    if (
+        (credit && identity.test(credit[1])) ||
+        (generic && (!generic[1] || identity.test(generic[1])))
+    ) {
+        return { column: normalized.column, kind: "assistant signature" };
+    }
+    return null;
+}

package/githooks/commit-message.mjs

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+import { readFileSync } from "node:fs";
+import { relative } from "node:path";
+import { attribution } from "./attribution.mjs";
+
+const file = process.argv[2];
+const lines = readFileSync(file, "utf8").split(/\r?\n/);
+let rejected = false;
+for (const [index, line] of lines.entries()) {
+    // Git's verbose diff starts at the scissors comment; other comments are inert.
+    if (/^#.*>8/.test(line)) break;
+    if (line.startsWith("#")) continue;
+    const finding = attribution(line);
+    if (!finding) continue;
+    console.error(
+        `${relative(process.cwd(), file)}:${index + 1}:${finding.column}: error: ${finding.kind}; attribution is not allowed in commit messages.`,
+    );
+    rejected = true;
+}
+if (rejected) {
+    console.error("Remove the assistant credit and commit again.");
+    process.exitCode = 1;
+}

package/githooks/commit-msg

@@ -1,40 +1,8 @@
 #!/usr/bin/env sh
-#
-# Reject commit messages that carry AI/assistant attribution.
-#
-# This project does not want Co-Authored-By trailers naming an AI assistant, nor
-# "Generated with Claude Code"-style signatures, in its history. The matching CI
-# guard is the shared HeroicLands/.github/actions/no-attribution action, which
-# this repository's .github/workflows/no-attribution.yml calls. That action holds
-# the pattern for every repository; this hook is the only other copy, because a
-# git hook runs from your checkout and cannot live in an action. Keep them in sync.
-#
-# Installed for everyone via the package.json "prepare" script, which points
-# git at this directory (`git config core.hooksPath .githooks`) on `npm install`.
+# SPDX-License-Identifier: GPL-3.0-or-later
+# Check the commit message using the same contract as the shared CI action.
 
 . "$(dirname "$0")/hook-enabled.sh"
-
-# On unless refused: it costs nothing, and the No Attribution workflow enforces
-# the same rule on GitHub, so opting out locally only moves the failure later.
 hook_enabled noAttribution true || exit 0
 
-msg_file="$1"
-
-# Scan only the real message: drop the diff appended by `commit --verbose` (from
-# the scissors comment onward) and strip remaining comment lines.
-content="$(sed '/^#.*>8/,$d' "$msg_file" | grep -v '^#')"
-
-# Anchored to the start of a line: real attribution is a trailer / signature at
-# column 0, so prose that merely *mentions* these phrases mid-sentence (e.g. this
-# hook's own docs) does not trip it. The generated-with branch tolerates a
-# leading emoji/space.
-pattern='^[[:space:]]*co-authored-by:.*(claude|anthropic)|^[^[:alpha:]]*generated with .*claude code'
-
-if printf '%s\n' "$content" | grep -iEq "$pattern"; then
-    echo "commit-msg: AI/assistant attribution is not allowed in commit messages." >&2
-    printf '%s\n' "$content" | grep -iEn "$pattern" | sed 's/^/    /' >&2
-    echo "Remove the 'Co-Authored-By: …' / 'Generated with Claude Code' line and commit again." >&2
-    exit 1
-fi
-
-exit 0
+exec node "$(dirname "$0")/commit-message.mjs" "$1"