feat(okr): delt bundle-root-relativ lenke-resolver + zero-dangling relasjoner (SC relasjoner) [skip-docs]

lib/innboks-relations.mjs

@@ -0,0 +1,49 @@
+// innboks-relations.mjs
+// Step 6: deterministisk relasjons-resolusjon innen KJOERINGENS konsept-sett
+// (lukket lenke-vokabular). For hvert konsept oppdages referanser til ANDRE
+// emitterte konsepter (exact-title substring, case-insensitivt) og emitteres som
+// leading-'/' bundle-root-lenker bygd paa malet-konseptets destRel (satt i Step 5,
+// kjent FOER skriv -- Pass-2 ordering-fiks). Asserterer zero-dangling mot de
+// emitterte destRel-stiene og at hver generert lenke er trygg (delt okf-links-
+// allow-list). v1-narrowing: kun innen-kjoering-settet -- lenking til pre-
+// eksisterende tre-konsepter er v1.1. Zero npm dependencies.
+
+import { isSafeBundleLink } from './okf-links.mjs';
+
+const REL_HEADING = '## Relaterte dokumenter';
+
+// concepts (beriket av projectFrontmatter, m/ destRel) -> samme konsepter m/
+// relations[] + body utvidet med en deterministisk relasjons-seksjon.
+export function resolveRelations(concepts) {
+  const emitted = new Set(concepts.map((c) => c.destRel));
+
+  return concepts.map((concept) => {
+    const haystack = `${concept.title}\n${concept.body}`.toLowerCase();
+    const found = new Map(); // target -> { title, target, destRel }
+
+    for (const other of concepts) {
+      if (other === concept) continue;
+      if (!other.title || !other.destRel) continue;
+      if (!haystack.includes(other.title.toLowerCase())) continue;
+
+      const target = `/${other.destRel}`;
+      if (!isSafeBundleLink(target)) {
+        throw new Error(`innboks-relations: utrygg generert lenke ${target}`);
+      }
+      if (!emitted.has(other.destRel)) {
+        throw new Error(`innboks-relations: dangling relasjon ${other.destRel}`);
+      }
+      found.set(target, { title: other.title, target, destRel: other.destRel });
+    }
+
+    const relations = [...found.values()].sort((a, b) => a.target.localeCompare(b.target));
+
+    let body = concept.body;
+    if (relations.length > 0) {
+      const links = relations.map((r) => `- [${r.title}](${r.target})`).join('\n');
+      body = `${concept.body}\n\n${REL_HEADING}\n\n${links}\n`;
+    }
+
+    return { ...concept, relations, body };
+  });
+}

lib/okf-links.mjs

@@ -0,0 +1,39 @@
+// okf-links.mjs
+// Delt bundle-root-relativ lenke-resolver (Step 6), brukt av BAADE relasjons-
+// emitteringen (innboks-relations) og okf-check++ --strict-ingest (Step 8).
+// Konvensjon: en trygg bundle-lenke er ROOT-RELATIV med leading '/' (resolveres
+// mot bundle-rota, jf. SC-regex \]\(/.*\.md\)). Avviser '../'-escape, absolutt
+// Windows-sti (backslash), og scheme-lenker (file://, http(s)://). Den ENESTE
+// lenke-allow-listen -- delt slik at emit og validering aldri divergerer.
+// Zero npm dependencies.
+
+import path from 'node:path';
+
+// Scheme-prefiks (file://, http://, https://, ...) -- avvises uansett.
+const SCHEME_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
+// '..'-segment hvor som helst i stien (escape ut av bundle-rota).
+const PARENT_SEGMENT_RE = /(^|\/)\.\.(\/|$)/;
+
+// Sann hvis target er en trygg, bundle-root-relativ .md-lenke (leading '/').
+export function isSafeBundleLink(target) {
+  if (typeof target !== 'string' || target === '') return false;
+  if (target.includes('\0')) return false; // null-byte
+  if (target.includes('\\')) return false; // backslash (Windows-sti)
+  if (SCHEME_RE.test(target)) return false; // file://, http(s)://, ...
+  if (!target.startsWith('/')) return false; // maa vaere bundle-root-relativ
+  if (PARENT_SEGMENT_RE.test(target)) return false; // ingen '..'-escape
+  if (!target.endsWith('.md')) return false; // bundle-konseptlenker er .md
+  return true;
+}
+
+// Resolverer en trygg bundle-lenke til absolutt sti UNDER bundleRoot, ellers null.
+// Belt-and-suspenders: isSafeBundleLink avviser '..' allerede, men confinement
+// re-sjekkes paa den resolverte stien.
+export function resolveBundleLink(target, bundleRoot) {
+  if (!isSafeBundleLink(target)) return null;
+  const rel = target.replace(/^\/+/, '');
+  const root = path.resolve(bundleRoot);
+  const resolved = path.resolve(root, rel);
+  if (resolved !== root && !resolved.startsWith(root + path.sep)) return null;
+  return resolved;
+}