mandrel 2.60.0 → 2.62.0

package/.agents/scripts/lib/baselines/kinds/lighthouse.js

@@ -1,87 +0,0 @@
-/**
- * kinds/lighthouse.js — per-kind module for the Lighthouse audit baseline
- * (Story #1891). Row shape: `{ route, performance, accessibility,
- * bestPractices, seo }`. The key field is `route` (a path-like string that
- * still passes the path-canon checks for absolute / `..` rejection).
- *
- * Higher score = better. New routes inherit a base of 100 for each axis
- * (so lower scores register as regressions — a new route must meet the
- * bar); dropped routes inherit a head of 100 (so a higher base registers
- * as an improvement). Unlike the file-derived kinds, compare emits no
- * `additions` bucket. Scaffold is generated by `makeBaselineKind`
- * (Story #3983).
- */
-
-import { canonicalise } from '../path-canon.js';
-import { makeBaselineKind } from './kind-factory.js';
-
-export const name = 'lighthouse';
-export const keyField = 'route';
-
-const LH_AXES = ['performance', 'accessibility', 'bestPractices', 'seo'];
-
-function canonRoute(route) {
-  // Routes look like `/`, `/dashboard`, or `pricing` — strip the leading
-  // slash so the canonicaliser doesn't see them as absolute paths.
-  if (typeof route !== 'string') return canonicalise(route);
-  const stripped = route.startsWith('/') ? route.slice(1) : route;
-  if (stripped.length === 0) return '/';
-  return canonicalise(stripped);
-}
-
-export function projectRow(row) {
-  return {
-    route: canonRoute(row.route),
-    performance: Number(row.performance),
-    accessibility: Number(row.accessibility),
-    bestPractices: Number(row.bestPractices),
-    seo: Number(row.seo),
-  };
-}
-
-function meanOf(rows, axis) {
-  let sum = 0;
-  for (const r of rows) sum += r[axis] ?? 0;
-  return Number((sum / rows.length).toFixed(2));
-}
-
-function aggregate(rows) {
-  if (!rows || rows.length === 0) {
-    return { performance: 0, accessibility: 0, bestPractices: 0, seo: 0 };
-  }
-  return {
-    performance: meanOf(rows, 'performance'),
-    accessibility: meanOf(rows, 'accessibility'),
-    bestPractices: meanOf(rows, 'bestPractices'),
-    seo: meanOf(rows, 'seo'),
-  };
-}
-
-function perfectLighthouseRow(route) {
-  return {
-    route,
-    performance: 100,
-    accessibility: 100,
-    bestPractices: 100,
-    seo: 100,
-  };
-}
-
-export const {
-  kernelVersion,
-  rowIdentity,
-  sortRows,
-  rollup,
-  compare,
-  applyEpsilon,
-  mergeRows,
-} = makeBaselineKind({
-  keyField,
-  kernelVersion: '1.0.0',
-  axes: LH_AXES,
-  betterWhen: 'higher',
-  aggregate,
-  missingBasePolicy: 'perfect',
-  removedRowPolicy: { kind: 'perfect-head' },
-  perfectRow: perfectLighthouseRow,
-});

package/.agents/scripts/lib/baselines/kinds/lint.js

@@ -1,184 +0,0 @@
-/**
- * kinds/lint.js — per-kind module for the lint baseline (Story #1891).
- *
- * Declares:
- *   - `name`: kind identifier matching the per-kind schema filename.
- *   - `keyField`: row field used as the rollup key (`path` here).
- *   - `kernelVersion()`: the lint kernel is the in-repo formatter contract
- *      — it has no upstream library version to track, so we ship a static
- *      semver and bump it whenever the rollup math or row shape changes.
- *   - `rollup(rows, components)`: aggregate per-component lint counts.
- */
-
-import { componentMatches } from '../component-matcher.js';
-import { canonicalise } from '../path-canon.js';
-import { mergeRowsByScope } from '../scope.js';
-
-export const name = 'lint';
-export const keyField = 'path';
-const KERNEL_VERSION = '1.0.0';
-
-export function kernelVersion() {
-  return KERNEL_VERSION;
-}
-
-/**
- * Aggregate `rows` into a `{ '*': {...}, [component]: {...} }` rollup. The
- * caller passes `components` as an array of `{ name, includes, excludes }`
- * objects. When `components` is empty or undefined the rollup carries only
- * the whole-repo `*` key.
- *
- * Rollup math for lint: sum of `errorCount` and `warningCount` across the
- * matching rows.
- */
-export function rollup(rows, components = []) {
-  const all = { errorCount: 0, warningCount: 0 };
-  const buckets = new Map();
-  for (const row of rows ?? []) {
-    all.errorCount += row.errorCount ?? 0;
-    all.warningCount += row.warningCount ?? 0;
-    for (const c of components ?? []) {
-      if (componentMatches(c, row.path)) {
-        const existing = buckets.get(c.name) ?? {
-          errorCount: 0,
-          warningCount: 0,
-        };
-        existing.errorCount += row.errorCount ?? 0;
-        existing.warningCount += row.warningCount ?? 0;
-        buckets.set(c.name, existing);
-      }
-    }
-  }
-  const out = { '*': all };
-  for (const [name, value] of buckets) out[name] = value;
-  return out;
-}
-
-/**
- * Project a raw row into the canonical lint row shape. `path` is funnelled
- * through the canonicaliser — every kind exposes a `projectRow` so the
- * writer can normalise rows uniformly.
- */
-export function projectRow(row) {
-  return {
-    path: canonicalise(row.path),
-    errorCount: row.errorCount ?? 0,
-    warningCount: row.warningCount ?? 0,
-  };
-}
-
-/**
- * Canonical row identity (Story #5215). This kind does not use the shared
- * factory scaffold, so it declares the protocol member itself; `path` is
- * unique per row here, which a shipped-baseline injectivity test pins.
- *
- * @param {{path: string, errorCount: number, warningCount: number}} row
- * @returns {string}
- */
-export function rowIdentity(row) {
-  return row.path;
-}
-
-export function sortRows(rows) {
-  return [...rows].sort((a, b) => a.path.localeCompare(b.path));
-}
-
-/**
- * Pure compare(head, base) for the lint kind. Diffs rows by `path`.
- *
- * Classification (per row key):
- *   - regression: head has more errorCount or warningCount than base
- *   - improvement: head has fewer errorCount or warningCount than base
- *   - unchanged: counts match
- *
- * A row present in `head` but missing from `base` is treated as a new
- * row — a regression if it carries any errors/warnings, otherwise
- * unchanged. A row present in `base` but missing from `head` is treated
- * as an improvement when it had findings, otherwise unchanged.
- *
- * No I/O. No process exit. No friction emission.
- */
-export function compare(head, base) {
-  const headRows = Array.isArray(head?.rows) ? head.rows : [];
-  const baseRows = Array.isArray(base?.rows) ? base.rows : [];
-  const baseByKey = new Map();
-  for (const r of baseRows) baseByKey.set(r.path, r);
-  const seen = new Set();
-  const regressions = [];
-  const improvements = [];
-  const unchanged = [];
-  for (const h of headRows) {
-    seen.add(h.path);
-    const b = baseByKey.get(h.path);
-    const headTotal = (h.errorCount ?? 0) + (h.warningCount ?? 0);
-    if (!b) {
-      if (headTotal > 0) regressions.push({ key: h.path, head: h, base: null });
-      else unchanged.push({ key: h.path, head: h, base: null });
-      continue;
-    }
-    const errDelta = (h.errorCount ?? 0) - (b.errorCount ?? 0);
-    const warnDelta = (h.warningCount ?? 0) - (b.warningCount ?? 0);
-    if (errDelta > 0 || warnDelta > 0) {
-      regressions.push({ key: h.path, head: h, base: b });
-    } else if (errDelta < 0 || warnDelta < 0) {
-      improvements.push({ key: h.path, head: h, base: b });
-    } else {
-      unchanged.push({ key: h.path, head: h, base: b });
-    }
-  }
-  for (const b of baseRows) {
-    if (seen.has(b.path)) continue;
-    const baseTotal = (b.errorCount ?? 0) + (b.warningCount ?? 0);
-    if (baseTotal > 0) improvements.push({ key: b.path, head: null, base: b });
-    else unchanged.push({ key: b.path, head: null, base: b });
-  }
-  return { regressions, improvements, unchanged };
-}
-
-/**
- * Pure stabilizer for s-stability-epsilon (Story #1964). The metric is
- * the maximum absolute delta across `errorCount` and `warningCount`. The
- * framework default for lint is epsilon 0 (counts are integer; any change
- * is meaningful), but the function honours any non-negative epsilon for
- * operator overrides. Missing-prior rows fall through.
- *
- * @param {Array<{path: string, errorCount: number, warningCount: number}>} prior
- * @param {Array<{path: string, errorCount: number, warningCount: number}>} regenerated
- * @param {number} epsilon non-negative absolute tolerance on count deltas
- * @returns {Array<object>}
- */
-export function applyEpsilon(prior, regenerated, epsilon) {
-  const priorRows = Array.isArray(prior) ? prior : [];
-  const regenRows = Array.isArray(regenerated) ? regenerated : [];
-  const eps = Number.isFinite(epsilon) && epsilon >= 0 ? epsilon : 0;
-  const priorByKey = new Map();
-  for (const r of priorRows) priorByKey.set(r.path, r);
-  return regenRows.map((row) => {
-    const p = priorByKey.get(row.path);
-    if (!p) return row;
-    const errDelta = Math.abs((row.errorCount ?? 0) - (p.errorCount ?? 0));
-    const warnDelta = Math.abs((row.warningCount ?? 0) - (p.warningCount ?? 0));
-    return Math.max(errDelta, warnDelta) <= eps ? p : row;
-  });
-}
-
-/**
- * Pure scope-aware merge for s-diff-scoped-writes (Story #1974). Lint rows
- * match by `path`. In diff mode, rows whose `path` is OUTSIDE
- * `scope.files` are preserved from `prior` verbatim; in-scope rows come
- * from `regenerated`. In full mode (or no scope), regenerated wins
- * everywhere.
- *
- * @param {Array<{path: string, errorCount: number, warningCount: number}>} prior
- * @param {Array<{path: string, errorCount: number, warningCount: number}>} regenerated
- * @param {{mode: 'full'|'diff', files: Set<string>}|null|undefined} scope
- * @returns {Array<object>}
- */
-export function mergeRows(prior, regenerated, scope) {
-  return mergeRowsByScope({
-    prior,
-    regenerated,
-    scope,
-    scopeKey: (row) => row.path,
-  });
-}

package/.agents/scripts/lib/baselines/orphan-pruner.js

@@ -1,233 +0,0 @@
-// .agents/scripts/lib/baselines/orphan-pruner.js
-//
-// Story #5012 — the measurement-free remedy that makes hard-failing on a stale
-// baseline row defensible.
-//
-// The scope gate (`check-baseline-scope.js`) blocks a PR that leaves a row
-// pointing at a file it deleted. A hard gate is only fair while its remedy is
-// cheap, and the existing remedy — re-run the scorer, re-derive the baseline —
-// costs a full coverage run or a full-tree MI re-score for what is arithmetic
-// on a row set. This pruner is that arithmetic.
-//
-// ## Measurement-free by contract
-//
-// Three prohibitions, each guarding a way the file could start lying:
-//
-//   1. **Never add a row.** Adding one means claiming a measurement nobody
-//      took. Producing rows stays the producers' exclusive job.
-//   2. **Never restamp `generatedAt`.** A fresh stamp over rows nobody
-//      re-measured is precisely the failure an age check exists to catch — the
-//      envelope would claim to describe today's tree on the strength of a
-//      deletion. The pruner carries the original stamp through untouched.
-//   3. **Never delete a row it cannot prove inert.** Only two classes qualify:
-//      the file is absent from disk, or the file is no longer matched by the
-//      gate's own `targetDirs` / `ignoreGlobs`. Everything else survives.
-//
-// ## Degrade, never guess
-//
-// A degraded inventory (`files: null` — unreadable `.c8rc.cjs`, absent
-// `targetDirs`) means scope is unknown, not empty. Treating it as empty would
-// make every row look out-of-scope and hand the pruner the whole baseline. So
-// an unreadable scope config falls back to **orphan-only** pruning: the
-// absent-from-disk class still resolves off the filesystem and is still safe,
-// while the out-of-scope class is suspended until scope can be read again.
-
-import fs from 'node:fs';
-import path from 'node:path';
-
-import { getKindModule } from './kernel.js';
-import { _internals as readerInternals } from './reader.js';
-import { EXTRA_REASONS } from './scope-assert.js';
-import {
-  buildScopeInventory,
-  isFileKeyed,
-  SCOPE_KINDS,
-} from './scope-inventory.js';
-import { writeFile } from './writer.js';
-
-/** Every kind whose rows key on a repo-relative file path. */
-export const PRUNABLE_KINDS = Object.freeze(SCOPE_KINDS.filter(isFileKeyed));
-
-/**
- * Partition a row set into the rows to keep and the rows to drop.
- *
- * Pure given its injected `existsOnDisk` predicate. `inScope` of `null` is the
- * degraded case: only the absent-from-disk class is prunable.
- *
- * @param {{
- *   rows: Array<Record<string, unknown>>,
- *   inScope: Set<string> | null,
- *   existsOnDisk: (relPath: string) => boolean,
- * }} params
- * @returns {{ keep: Array<object>, removed: Array<{ path: string, reason: string }> }}
- */
-export function planPrune({ rows, inScope, existsOnDisk } = {}) {
-  const keep = [];
-  const removed = [];
-  for (const row of Array.isArray(rows) ? rows : []) {
-    const key = row?.path;
-    if (typeof key !== 'string' || key.length === 0) {
-      keep.push(row);
-      continue;
-    }
-    if (!existsOnDisk(key)) {
-      removed.push({ path: key, reason: EXTRA_REASONS.ABSENT });
-      continue;
-    }
-    if (inScope !== null && !inScope.has(key)) {
-      removed.push({ path: key, reason: EXTRA_REASONS.OUT_OF_SCOPE });
-      continue;
-    }
-    keep.push(row);
-  }
-  return { keep, removed };
-}
-
-/**
- * Prune one parsed envelope and recompute its `rollup` through the kind's own
- * arithmetic (`kinds/<kind>.js#rollup`), so the pruned file stays internally
- * consistent and still validates against its schema. Recomputing by a private
- * formula here would let the rollup and the rows describe different trees.
- *
- * A rollup carrying component buckets beyond `*` is refused rather than
- * recomputed: the component globs that produced those buckets live in gate
- * config this module is not handed, and emitting a `*`-only rollup would
- * silently delete them.
- *
- * @param {{
- *   kind: string,
- *   envelope: object,
- *   inventory: { files: string[] | null },
- *   existsOnDisk?: (relPath: string) => boolean,
- * }} params
- * @returns {{
- *   envelope: object | null,
- *   removed: Array<{ path: string, reason: string }>,
- *   skipped: boolean,
- *   reason: string | null,
- * }}
- */
-export function pruneEnvelope({
-  kind,
-  envelope,
-  inventory,
-  existsOnDisk,
-} = {}) {
-  const rollupKeys = Object.keys(envelope?.rollup ?? {});
-  if (rollupKeys.some((key) => key !== '*')) {
-    return {
-      envelope: null,
-      removed: [],
-      skipped: true,
-      reason: `rollup carries component buckets (${rollupKeys.join(', ')}); prune them with the producer`,
-    };
-  }
-  const inScope = inventory?.files === null ? null : new Set(inventory.files);
-  const { keep, removed } = planPrune({
-    rows: envelope?.rows ?? [],
-    inScope,
-    existsOnDisk: existsOnDisk ?? (() => true),
-  });
-  if (removed.length === 0) {
-    return { envelope: null, removed: [], skipped: false, reason: null };
-  }
-  return {
-    envelope: {
-      ...envelope,
-      // `generatedAt` is carried by the spread, deliberately unmodified.
-      rollup: getKindModule(kind).rollup(keep, []),
-      rows: keep,
-    },
-    removed,
-    skipped: false,
-    reason: null,
-  };
-}
-
-/**
- * Read and JSON-parse a baseline file. Returns `null` when the file is absent
- * (a kind this repository does not use) and throws only on malformed JSON,
- * which is a real defect the caller should surface rather than swallow.
- *
- * @param {string} absPath
- * @param {typeof fs} fsImpl
- * @returns {object | null}
- */
-function readEnvelope(absPath, fsImpl) {
-  let raw;
-  try {
-    raw = fsImpl.readFileSync(absPath, 'utf8');
-  } catch {
-    return null;
-  }
-  return JSON.parse(raw);
-}
-
-/**
- * Prune one kind end to end: resolve its baseline path, read it, build the
- * scope inventory, plan, and (unless `check`) write.
- *
- * @param {object} params
- * @returns {object} One entry of the report's `kinds` array.
- */
-function pruneKind({ kind, cwd, quality, check, fsImpl, requireFn }) {
-  const absPath = readerInternals.resolveBaselinePath(kind, { cwd });
-  const relPath = path.relative(cwd, absPath).split(path.sep).join('/');
-  const envelope = readEnvelope(absPath, fsImpl);
-  if (envelope === null) {
-    return { kind, path: relPath, present: false, removed: [], written: false };
-  }
-  const inventory = buildScopeInventory({ kind, cwd, quality, requireFn });
-  const result = pruneEnvelope({
-    kind,
-    envelope,
-    inventory,
-    existsOnDisk: (rel) => fsImpl.existsSync(path.resolve(cwd, rel)),
-  });
-  const base = {
-    kind,
-    path: relPath,
-    present: true,
-    degraded: inventory.degraded,
-    degradedReason: inventory.degraded ? inventory.reason : null,
-    skipped: result.skipped,
-    skipReason: result.reason,
-    removed: result.removed,
-    written: false,
-  };
-  if (result.envelope === null || check) return base;
-  writeFile(absPath, result.envelope, { fsImpl });
-  return { ...base, written: true };
-}
-
-/**
- * Prune every file-keyed baseline under `cwd`.
- *
- * @param {{
- *   cwd?: string,
- *   kinds?: string[],
- *   check?: boolean,
- *   quality?: object,
- *   fsImpl?: typeof fs,
- *   requireFn?: (id: string) => object,
- * }} params
- * @returns {{ kinds: Array<object>, removedCount: number, writtenCount: number, check: boolean }}
- */
-export function runPrune({
-  cwd = process.cwd(),
-  kinds = PRUNABLE_KINDS,
-  check = false,
-  quality,
-  fsImpl = fs,
-  requireFn,
-} = {}) {
-  const results = kinds.map((kind) =>
-    pruneKind({ kind, cwd, quality, check, fsImpl, requireFn }),
-  );
-  return {
-    check,
-    kinds: results,
-    removedCount: results.reduce((sum, r) => sum + r.removed.length, 0),
-    writtenCount: results.filter((r) => r.written).length,
-  };
-}