@sema-agent/wiki-gate 0.0.0-stage → 7.67.1

package/dist/versions.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Versions, severities and the age rules — the readings every gate entry grades a finding by.
+ */
+/** A finding's severity: a warning prints, a failure sets the exit code. */
+export type Severity = "warn" | "fail";
+/** A `V` sentence this many minor versions behind the version under check is reported (never failed). */
+export declare const V_AGE_MINORS = 3;
+/** A `U` sentence whose acceptance cell is this many releases behind the repository is reported (never failed). */
+export declare const U_AGE_RELEASES = 3;
+/** `[major, minor, patch]` of an `X.Y.Z` version; undefined for anything else. */
+export declare function parseVersion(v: unknown): [number, number, number] | undefined;
+/** -1 / 0 / 1; a version that is not X.Y.Z throws (a severity judged on NaN would read every finding as a warning). */
+export declare function compareVersions(a: string, b: string): -1 | 0 | 1;
+/**
+ * Where a severity is judged: the version under check, the strict reading, and the version findings fail from — the
+ * repository's own, for the genre under check.
+ */
+export interface SeverityContext {
+    readonly version: string;
+    readonly strict?: boolean;
+    readonly redFrom: string;
+}
+/** A finding's severity. `finding.fixed` is a severity the version does not move. */
+export declare function severityOf(finding: {
+    readonly fixed?: Severity;
+}, { version, strict, redFrom }: SeverityContext): Severity;
+/** One `run:` ref read: who ran it, against which package at which version, and when. */
+export interface RunRef {
+    readonly who: string;
+    readonly pkg: string;
+    readonly version: string;
+    readonly date: string;
+}
+/** `who@pkg@ver@date` — the package may be scoped (`dgx@@sema-agent/server@7.145.0@2026-11-05`). */
+export declare function parseRun(body: string): RunRef | undefined;
+/** The repository a gate checks: its package name, the version its releases carry, and the word its pages name it by. */
+export interface RepoIdentity {
+    readonly name: string;
+    readonly version: string;
+}
+/**
+ * How old a `V` sentence is, against the version of the package it names that this check reads — never against the
+ * page's own `verified:` line, which moves only when the page is restamped. It takes {@link parseRun}'s answer as it
+ * is; a run that answer could not read is a caller's fault and throws (the anchors gate never asks about one).
+ */
+export declare function vAgeFinding(run: RunRef | undefined, repo: RepoIdentity): {
+    message: string;
+    fixed: Severity;
+} | undefined;
+/**
+ * How many releases separate two versions of one repository, as that repository releases: undefined when it cannot
+ * say. This reading counts minor versions inside one major (a repository that releases by patch hands in its own).
+ */
+export type ReleaseDistance = (from: string, to: string) => number | undefined;
+/** The distance by minor versions inside one major; another major is a distance this reading cannot say. */
+export declare const minorReleaseDistance: ReleaseDistance;
+/**
+ * How old a `U` sentence is: its acceptance cell's version against the repository's, by the repository's release
+ * distance. Never failed — a person, not a machine, re-runs a black-box cell.
+ */
+export declare function uAgeFinding(cellVersion: string, repo: RepoIdentity, distance: ReleaseDistance): {
+    message: string;
+    fixed: Severity;
+} | undefined;

package/dist/versions.js

@@ -0,0 +1,53 @@
+export const V_AGE_MINORS = 3;
+export const U_AGE_RELEASES = 3;
+export function parseVersion(v) {
+    const m = /^(\d+)\.(\d+)\.(\d+)$/.exec(String(v));
+    return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : undefined;
+}
+export function compareVersions(a, b) {
+    const pa = parseVersion(a);
+    const pb = parseVersion(b);
+    if (pa === undefined || pb === undefined)
+        throw new Error(`a version must read X.Y.Z, got ${JSON.stringify(pa === undefined ? a : b)}`);
+    for (let i = 0; i < 3; i++)
+        if (pa[i] !== pb[i])
+            return pa[i] < pb[i] ? -1 : 1;
+    return 0;
+}
+export function severityOf(finding, { version, strict = false, redFrom }) {
+    if (finding.fixed !== undefined)
+        return finding.fixed;
+    return strict || compareVersions(version, redFrom) >= 0 ? "fail" : "warn";
+}
+export function parseRun(body) {
+    const m = /^([a-z0-9-]+)@(@?[a-z0-9][a-z0-9./_-]*)@(\d+\.\d+\.\d+)@(\d{4}-\d{2}-\d{2})$/.exec(body);
+    return m ? { who: m[1], pkg: m[2], version: m[3], date: m[4] } : undefined;
+}
+export function vAgeFinding(run, repo) {
+    if (run === undefined)
+        throw new TypeError("vAgeFinding: no run to judge (parseRun read none)");
+    if (run.pkg !== repo.name)
+        return { message: `the run names ${run.pkg}, of which this check reads no version: its age cannot be judged`, fixed: "warn" };
+    const [maj, min] = parseVersion(run.version);
+    const [nowMaj, nowMin] = parseVersion(repo.version);
+    if (maj !== nowMaj)
+        return { message: `the run is at ${run.version}, another major than ${repo.version}`, fixed: "fail" };
+    if (nowMin - min >= V_AGE_MINORS)
+        return { message: `the run is at ${run.version}, ${nowMin - min} minor versions behind ${repo.version}`, fixed: "warn" };
+    return undefined;
+}
+export const minorReleaseDistance = (from, to) => {
+    const a = parseVersion(from);
+    const b = parseVersion(to);
+    if (a === undefined || b === undefined || a[0] !== b[0])
+        return undefined;
+    return b[1] - a[1];
+};
+export function uAgeFinding(cellVersion, repo, distance) {
+    const d = distance(cellVersion, repo.version);
+    if (d === undefined)
+        return { message: `the acceptance cell is at ${cellVersion}, a distance from ${repo.version} this repository's release reading cannot say: its age cannot be judged`, fixed: "warn" };
+    if (d >= U_AGE_RELEASES)
+        return { message: `the acceptance cell is at ${cellVersion}, ${d} releases behind ${repo.version}`, fixed: "warn" };
+    return undefined;
+}

package/package.json

@@ -1,6 +1,38 @@
 {
   "name": "@sema-agent/wiki-gate",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "7.67.1",
+  "private": false,
+  "description": "The sema wiki gates as a library: one reader module with three gate entries (anchors, freshness, coverage) and the stamp, over a repository you name. The repository's own readers and generators are handed in; the rules are the package's.",
+  "type": "module",
+  "license": "BUSL-1.1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sema-agent/sema-core.git",
+    "directory": "packages/wiki-gate"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20.18.1"
+  },
+  "dependencies": {
+    "typescript": "5.7.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.json --emitDeclarationOnly --removeComments false"
+  },
+  "gitHead": "f37485960eb53ae879d3f16fa176ecc0ea1506c8"
+}