@web-hig/core 1.12.2

package/index.mjs

@@ -0,0 +1,4 @@
+export { loadRegistry, parseRegistryYaml, filterRulesByContract } from './lib/registry.mjs';
+export { loadProjectConfig, defaultProjectConfig } from './lib/config.mjs';
+export { createReport, printTerminalReport, severityBucketForRule } from './lib/report.mjs';
+export { resolveHigRoot } from './lib/resolve-root.mjs';

package/lib/config.mjs

@@ -0,0 +1,99 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const DEFAULTS = {
+  profile: 'practical',
+  archetype: 'application',
+  framework: { name: null },
+  scope: { files: ['src/**'], exclude: [], routes: ['/**'] },
+  gates: { blocking: 'fail', warnings: 'report', observations: 'report' },
+};
+
+export function defaultProjectConfig(higVersion) {
+  return {
+    version: higVersion,
+    ...structuredClone(DEFAULTS),
+  };
+}
+
+function parseScalar(line) {
+  const trimmed = line.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+
+/** Minimal web-hig.yaml parser (no dependency). */
+export function loadProjectConfig(cwd, fileName = 'web-hig.yaml') {
+  const configPath = path.join(cwd, fileName);
+  if (!fs.existsSync(configPath)) {
+    return { configPath: null, config: null, exists: false };
+  }
+
+  const text = fs.readFileSync(configPath, 'utf8');
+  const config = structuredClone(DEFAULTS);
+  let version = null;
+  let section = null;
+
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.replace(/#.*$/, '').trimEnd();
+    if (!line.trim() || line.trim().startsWith('#')) continue;
+
+    if (/^scope:\s*$/.test(line)) {
+      section = 'scope';
+      continue;
+    }
+    if (/^framework:\s*$/.test(line)) {
+      section = 'framework';
+      continue;
+    }
+    if (/^gates:\s*$/.test(line)) {
+      section = 'gates';
+      continue;
+    }
+
+    const top = line.match(/^(\w+):\s*(.*)$/);
+    if (top && !line.startsWith(' ')) {
+      section = null;
+      const [, key, value] = top;
+      if (key === 'version') version = parseScalar(value);
+      if (key === 'profile') config.profile = parseScalar(value);
+      if (key === 'archetype') config.archetype = parseScalar(value);
+      continue;
+    }
+
+    const nested = line.match(/^\s{2}(\w+):\s*(.*)$/);
+    if (!nested) continue;
+    const [, key, value] = nested;
+
+    if (section === 'framework' && key === 'name') {
+      config.framework.name = parseScalar(value);
+    }
+    if (section === 'gates') {
+      config.gates[key] = parseScalar(value);
+    }
+    if (section === 'scope' && (key === 'files' || key === 'exclude' || key === 'routes')) {
+      if (!Array.isArray(config.scope[key])) config.scope[key] = [];
+    }
+  }
+
+  const lines = text.split(/\r?\n/);
+  let scopeList = null;
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (/^\s{2}files:\s*$/.test(line)) scopeList = 'files';
+    else if (/^\s{2}exclude:\s*$/.test(line)) scopeList = 'exclude';
+    else if (/^\s{2}routes:\s*$/.test(line)) scopeList = 'routes';
+    else if (/^\s{2}\w/.test(line) && !/^\s{4}-/.test(line)) scopeList = null;
+    else if (scopeList && /^\s{4}-\s+(.+)$/.test(line)) {
+      config.scope[scopeList].push(parseScalar(line.match(/^\s{4}-\s+(.+)$/)[1]));
+    }
+  }
+
+  return {
+    configPath,
+    exists: true,
+    config: { version, ...config },
+  };
+}

package/lib/registry.mjs

@@ -0,0 +1,55 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function parseRegistryYaml(yaml) {
+  const version = yaml.match(/^version:\s*"([^"]+)"/m)?.[1];
+  const rules = new Map();
+  for (const match of yaml.matchAll(/^  (HIG-[A-Z0-9]+-\d+):\r?\n((?:    .+\r?\n)*)/gm)) {
+    const id = match[1];
+    const body = match[2];
+    const pick = (key) => body.match(new RegExp(`^    ${key}:\\s*(.+)$`, 'm'))?.[1]?.trim();
+    const profiles = [...body.matchAll(/^    profiles:\r?\n((?:      - \S+\r?\n)*)/gm)][0];
+    const profileList = profiles
+      ? [...profiles[1].matchAll(/^      - (\S+)/gm)].map((m) => m[1])
+      : [];
+    const archetypeBlock = [...body.matchAll(/^    archetypes:\r?\n((?:      - \S+\r?\n)*)/gm)][0];
+    const archetypeList = archetypeBlock
+      ? [...archetypeBlock[1].matchAll(/^      - (\S+)/gm)].map((m) => m[1])
+      : [];
+    const evalBlock = [...body.matchAll(/^    evaluation:\r?\n((?:      - \S+\r?\n)*)/gm)][0];
+    const evaluationList = evalBlock
+      ? [...evalBlock[1].matchAll(/^      - (\S+)/gm)].map((m) => m[1])
+      : [];
+
+    rules.set(id, {
+      id,
+      severity: pick('severity'),
+      requirement: pick('requirement')?.replace(/^"|"$/g, ''),
+      profiles: profileList,
+      archetypes: archetypeList,
+      evaluation: evaluationList,
+      autofix: pick('autofix'),
+      module: pick('module'),
+      hig_section: pick('hig_section')?.replace(/^"|"$/g, ''),
+      eslint_rule: pick('eslint_rule'),
+    });
+  }
+  return { version, rules };
+}
+
+export function loadRegistry(higRoot) {
+  const filePath = path.join(higRoot, 'rules', 'registry.yaml');
+  const yaml = fs.readFileSync(filePath, 'utf8');
+  return parseRegistryYaml(yaml);
+}
+
+export function filterRulesByContract(registry, { profile, archetype }) {
+  const applicable = [];
+  for (const rule of registry.rules.values()) {
+    if (!rule.profiles.includes(profile)) continue;
+    if (!rule.archetypes.includes(archetype)) continue;
+    if (!rule.evaluation.includes('static')) continue;
+    applicable.push(rule);
+  }
+  return applicable;
+}

package/lib/report.mjs

@@ -0,0 +1,62 @@
+const SEVERITY_TO_BUCKET = {
+  error: 'blocking',
+  warning: 'warnings',
+  info: 'observations',
+};
+
+export function severityBucketForRule(severity) {
+  return SEVERITY_TO_BUCKET[severity] ?? 'warnings';
+}
+
+export function createReport({
+  higVersion,
+  profile,
+  archetype,
+  framework,
+  findings = [],
+}) {
+  const counts = { blocking: 0, warnings: 0, observations: 0 };
+  for (const finding of findings) {
+    counts[finding.severity_bucket] = (counts[finding.severity_bucket] ?? 0) + 1;
+  }
+
+  return {
+    hig_version: higVersion,
+    profile,
+    archetype,
+    framework: framework ?? null,
+    severity_counts: counts,
+    findings,
+  };
+}
+
+export function printTerminalReport(report) {
+  const lines = [
+    `Web HIG v${report.hig_version}`,
+    '',
+    `Profile: ${capitalize(report.profile)}`,
+    `Archetype: ${capitalize(report.archetype)}`,
+  ];
+  if (report.framework) lines.push(`Framework: ${capitalize(report.framework)}`);
+  lines.push(
+    '',
+    `BLOCKING        ${report.severity_counts.blocking}`,
+    `WARNINGS        ${report.severity_counts.warnings}`,
+    `OBSERVATIONS    ${report.severity_counts.observations}`,
+  );
+
+  if (report.findings.length) {
+    lines.push('', 'Findings:');
+    for (const f of report.findings) {
+      const loc = f.location ? ` (${f.location})` : '';
+      lines.push(`  [${f.rule_id}] ${f.message}${loc}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+function capitalize(value) {
+  if (!value) return value;
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}

package/lib/resolve-root.mjs

@@ -0,0 +1,19 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function resolveHigRoot(startDir = process.cwd()) {
+  if (process.env.WEB_HIG_ROOT) {
+    const root = path.resolve(process.env.WEB_HIG_ROOT);
+    if (fs.existsSync(path.join(root, 'rules', 'registry.yaml'))) return root;
+  }
+
+  let dir = path.resolve(startDir);
+  for (let i = 0; i < 12; i += 1) {
+    if (fs.existsSync(path.join(dir, 'rules', 'registry.yaml'))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  return null;
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@web-hig/core",
+  "version": "1.12.2",
+  "description": "Shared evaluator engine for The Web HIG conformance tooling",
+  "type": "module",
+  "exports": {
+    ".": "./index.mjs"
+  },
+  "files": [
+    "index.mjs",
+    "lib"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/frozonfreak/hig.git",
+    "directory": "packages/core"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}