@nimiplatform/nimi-coding 0.4.0 → 0.6.0

package/cli/lib/authority/diff.mjs

@@ -3,6 +3,7 @@ import { stat } from "node:fs/promises";
 import path from "node:path";
 
 import { compileAuthorityPath } from "./compile.mjs";
+import { createCompiledAuthoritySnapshot } from "./compiled-snapshot.mjs";
 import { compareText, makeDiagnostic, portablePath, sortDiagnostics } from "./diagnostics.mjs";
 
 const DIFF_FORMAT = "nimicoding.authority-diff/v1";
@@ -46,14 +47,14 @@ function portableMapping(mapping, basePath) {
   return { ...mapping, file: portablePath(mapping.file, basePath) };
 }
 
-function mappedAt(compiled, unitIndex, pointer, basePath) {
-  const exact = compiled.sourceMap.fields[`/units/${unitIndex}${pointer}`];
-  if (exact) return portableMapping(exact, basePath);
+function mappedAt(snapshot, unitIndex, pointer) {
+  const exact = snapshot.compiled.sourceMap.fields[`/units/${unitIndex}${pointer}`];
+  if (exact) return portableMapping(exact, snapshot.inputRoot);
   const prefix = `/units/${unitIndex}${pointer}/`;
-  const nested = Object.entries(compiled.sourceMap.fields)
+  const nested = Object.entries(snapshot.compiled.sourceMap.fields)
     .filter(([candidate]) => candidate.startsWith(prefix))
     .sort(([left], [right]) => compareText(left, right))[0]?.[1];
-  return portableMapping(nested, basePath);
+  return portableMapping(nested, snapshot.inputRoot);
 }
 
 function addChange(changes, { unitId, operation = "modified", pointer, before, after, beforeSource = null, afterSource = null }) {
@@ -68,7 +69,7 @@ function addChange(changes, { unitId, operation = "modified", pointer, before, a
   });
 }
 
-function compareScalar(changes, beforeEntry, afterEntry, pointer, beforeBase, afterBase) {
+function compareScalar(changes, beforeSnapshot, afterSnapshot, beforeEntry, afterEntry, pointer) {
   const before = beforeEntry.unit;
   const after = afterEntry.unit;
   const read = (value, parts) => parts.reduce((current, part) => current?.[part], value);
@@ -81,21 +82,21 @@ function compareScalar(changes, beforeEntry, afterEntry, pointer, beforeBase, af
     pointer,
     before: left,
     after: right,
-    beforeSource: mappedAt(beforeEntry.compiled, beforeEntry.index, pointer, beforeBase),
-    afterSource: mappedAt(afterEntry.compiled, afterEntry.index, pointer, afterBase),
+    beforeSource: mappedAt(beforeSnapshot, beforeEntry.unitIndex, pointer),
+    afterSource: mappedAt(afterSnapshot, afterEntry.unitIndex, pointer),
   });
 }
 
-function compareValueSet(changes, beforeEntry, afterEntry, pointer, beforeBase, afterBase) {
+function compareValueSet(changes, beforeSnapshot, afterSnapshot, beforeEntry, afterEntry, pointer) {
   const parts = pointer.slice(1).split("/");
   const read = (unit) => parts.reduce((current, part) => current?.[part], unit) ?? [];
   const beforeValues = read(beforeEntry.unit);
   const afterValues = read(afterEntry.unit);
   const beforeSet = new Set(beforeValues.map((value) => JSON.stringify(value)));
   const afterSet = new Set(afterValues.map((value) => JSON.stringify(value)));
-  for (const [operation, values, otherSet, entry, basePath, sourceSide] of [
-    ["removed", beforeValues, afterSet, beforeEntry, beforeBase, "beforeSource"],
-    ["added", afterValues, beforeSet, afterEntry, afterBase, "afterSource"],
+  for (const [operation, values, otherSet, snapshot, entry, sourceSide] of [
+    ["removed", beforeValues, afterSet, beforeSnapshot, beforeEntry, "beforeSource"],
+    ["added", afterValues, beforeSet, afterSnapshot, afterEntry, "afterSource"],
   ]) {
     values.forEach((value, index) => {
       if (otherSet.has(JSON.stringify(value))) return;
@@ -105,20 +106,20 @@ function compareValueSet(changes, beforeEntry, afterEntry, pointer, beforeBase,
         pointer,
         before: operation === "removed" ? value : null,
         after: operation === "added" ? value : null,
-        [sourceSide]: mappedAt(entry.compiled, entry.index, `${pointer}/${index}`, basePath),
+        [sourceSide]: mappedAt(snapshot, entry.unitIndex, `${pointer}/${index}`),
       });
     });
   }
 }
 
-function compareRelations(changes, beforeEntry, afterEntry, beforeBase, afterBase) {
+function compareRelations(changes, beforeSnapshot, afterSnapshot, beforeEntry, afterEntry) {
   const beforeRelations = beforeEntry.unit.relations;
   const afterRelations = afterEntry.unit.relations;
   const beforeSet = new Set(beforeRelations.map((edge) => `${edge.type}\0${edge.target}`));
   const afterSet = new Set(afterRelations.map((edge) => `${edge.type}\0${edge.target}`));
-  for (const [operation, edges, otherSet, entry, basePath, sourceSide] of [
-    ["removed", beforeRelations, afterSet, beforeEntry, beforeBase, "beforeSource"],
-    ["added", afterRelations, beforeSet, afterEntry, afterBase, "afterSource"],
+  for (const [operation, edges, otherSet, snapshot, entry, sourceSide] of [
+    ["removed", beforeRelations, afterSet, beforeSnapshot, beforeEntry, "beforeSource"],
+    ["added", afterRelations, beforeSet, afterSnapshot, afterEntry, "afterSource"],
   ]) {
     edges.forEach((edge, index) => {
       if (otherSet.has(`${edge.type}\0${edge.target}`)) return;
@@ -128,23 +129,23 @@ function compareRelations(changes, beforeEntry, afterEntry, beforeBase, afterBas
         pointer: "/relations",
         before: operation === "removed" ? edge : null,
         after: operation === "added" ? edge : null,
-        [sourceSide]: mappedAt(entry.compiled, entry.index, `/relations/${index}`, basePath),
+        [sourceSide]: mappedAt(snapshot, entry.unitIndex, `/relations/${index}`),
       });
     });
   }
 }
 
-function sideMappedAt(compiled, unitIndex, pointer, basePath, side) {
-  const mapped = mappedAt(compiled, unitIndex, pointer, basePath);
+function sideMappedAt(snapshot, unitIndex, pointer, side) {
+  const mapped = mappedAt(snapshot, unitIndex, pointer);
   return { ...mapped, file: path.posix.join(side, mapped.file) };
 }
 
-function transitionDiagnostics(before, after, beforeBase, afterBase) {
+function transitionDiagnostics(before, after) {
   const diagnostics = [];
-  const afterById = new Map(after.ir.units.map((unit) => [unit.id, unit]));
-  before.ir.units.forEach((unit, index) => {
-    if (afterById.has(unit.id)) return;
-    const mapped = sideMappedAt(before, index, "/id", beforeBase, "before");
+  for (const entry of before.byId.values()) {
+    const { unit, unitIndex } = entry;
+    if (after.byId.has(unit.id)) continue;
+    const mapped = sideMappedAt(before, unitIndex, "/id", "before");
     diagnostics.push(makeDiagnostic({
       code: "AUTH_DIFF_TRANSITION_INVALID",
       file: mapped.file,
@@ -155,12 +156,12 @@ function transitionDiagnostics(before, after, beforeBase, afterBase) {
         ? "retain the removed tombstone; permanent reserved-ID storage is not admitted"
         : "replace the active unit with a valid removed tombstone carrying an explicit reason",
     }));
-  });
-  const beforeById = new Map(before.ir.units.map((unit) => [unit.id, unit]));
-  after.ir.units.forEach((unit, index) => {
-    const previous = beforeById.get(unit.id);
-    if (!previous) return;
-    const mapped = sideMappedAt(after, index, "/id", afterBase, "after");
+  }
+  for (const entry of after.byId.values()) {
+    const { unit, unitIndex } = entry;
+    const previous = before.byId.get(unit.id)?.unit;
+    if (!previous) continue;
+    const mapped = sideMappedAt(after, unitIndex, "/id", "after");
     if (previous.lifecycle === "removed" && unit.lifecycle !== "removed") diagnostics.push(makeDiagnostic({
       code: "AUTH_DIFF_TRANSITION_INVALID",
       file: mapped.file,
@@ -177,18 +178,16 @@ function transitionDiagnostics(before, after, beforeBase, afterBase) {
       reason: `authority identity cannot change kind from ${previous.kind} to ${unit.kind}: ${unit.id}`,
       repair: "retain the original identity and declare a distinct ID for the new kind",
     }));
-  });
+  }
   return sortDiagnostics(diagnostics);
 }
 
-function compareUnits(before, after, beforeBase, afterBase) {
+function compareUnits(before, after) {
   const changes = [];
-  const beforeById = new Map(before.ir.units.map((unit, index) => [unit.id, { unit, index, compiled: before }]));
-  const afterById = new Map(after.ir.units.map((unit, index) => [unit.id, { unit, index, compiled: after }]));
-  const ids = [...new Set([...beforeById.keys(), ...afterById.keys()])].sort(compareText);
+  const ids = [...new Set([...before.byId.keys(), ...after.byId.keys()])].sort(compareText);
   for (const id of ids) {
-    const left = beforeById.get(id);
-    const right = afterById.get(id);
+    const left = before.byId.get(id);
+    const right = after.byId.get(id);
     if (!left) {
       addChange(changes, {
         unitId: id,
@@ -196,16 +195,16 @@ function compareUnits(before, after, beforeBase, afterBase) {
         pointer: "",
         before: null,
         after: right.unit,
-        afterSource: mappedAt(after, right.index, "/id", afterBase),
+        afterSource: mappedAt(after, right.unitIndex, "/id"),
       });
       continue;
     }
     if (!right) continue;
     for (const pointer of ["/kind", "/owner", "/lifecycle", "/metadata/title", "/metadata/reason", "/semantic/meaning", "/semantic/modality", "/semantic/statement", "/semantic/condition", "/semantic/failure"]) {
-      compareScalar(changes, left, right, pointer, beforeBase, afterBase);
+      compareScalar(changes, before, after, left, right, pointer);
     }
-    compareValueSet(changes, left, right, "/semantic/scope", beforeBase, afterBase);
-    compareRelations(changes, left, right, beforeBase, afterBase);
+    compareValueSet(changes, before, after, left, right, "/semantic/scope");
+    compareRelations(changes, before, after, left, right);
   }
   return changes.sort((left, right) => (
     compareText(left.unitId, right.unitId)
@@ -231,7 +230,7 @@ function budgetDiagnostic(requiredBytes, maxBytes) {
   });
 }
 
-export async function diffAuthorityPaths(beforePath, afterPath, { maxBytes = null } = {}) {
+export async function diffAuthorityPathsWithSnapshots(beforePath, afterPath, { maxBytes = null } = {}) {
   const [before, after, beforeBase, afterBase] = await Promise.all([
     compileAuthorityPath(beforePath),
     compileAuthorityPath(afterPath),
@@ -239,24 +238,46 @@ export async function diffAuthorityPaths(beforePath, afterPath, { maxBytes = nul
     sourceRoot(afterPath),
   ]);
   if (!before.ok || !after.ok) return {
-    ok: false,
-    diagnostics: sortDiagnostics([
-      ...sideDiagnostics(before.diagnostics, beforeBase, "before"),
-      ...sideDiagnostics(after.diagnostics, afterBase, "after"),
-    ]),
-    fileCount: before.fileCount + after.fileCount,
-    unitCount: 0,
-    diff: null,
+    beforeSnapshot: null,
+    afterSnapshot: null,
+    result: {
+      ok: false,
+      diagnostics: sortDiagnostics([
+        ...sideDiagnostics(before.diagnostics, beforeBase, "before"),
+        ...sideDiagnostics(after.diagnostics, afterBase, "after"),
+      ]),
+      fileCount: before.fileCount + after.fileCount,
+      unitCount: 0,
+      diff: null,
+      partial: false,
+    },
+  };
+  const beforeSnapshot = createCompiledAuthoritySnapshot(before, beforeBase);
+  const afterSnapshot = createCompiledAuthoritySnapshot(after, afterBase);
+  return {
+    beforeSnapshot,
+    afterSnapshot,
+    result: diffAuthoritySnapshots(beforeSnapshot, afterSnapshot, { maxBytes }),
   };
-  const invalidTransitions = transitionDiagnostics(before, after, beforeBase, afterBase);
+}
+
+export async function diffAuthorityPaths(beforePath, afterPath, options = {}) {
+  return (await diffAuthorityPathsWithSnapshots(beforePath, afterPath, options)).result;
+}
+
+export function diffAuthoritySnapshots(beforeSnapshot, afterSnapshot, { maxBytes = null } = {}) {
+  const before = beforeSnapshot.compiled;
+  const after = afterSnapshot.compiled;
+  const invalidTransitions = transitionDiagnostics(beforeSnapshot, afterSnapshot);
   if (invalidTransitions.length > 0) return {
     ok: false,
     diagnostics: invalidTransitions,
     fileCount: before.fileCount + after.fileCount,
     unitCount: 0,
     diff: null,
+    partial: false,
   };
-  const changes = compareUnits(before, after, beforeBase, afterBase);
+  const changes = compareUnits(beforeSnapshot, afterSnapshot);
   const diff = {
     format: DIFF_FORMAT,
     changes,
@@ -273,15 +294,17 @@ export async function diffAuthorityPaths(beforePath, afterPath, { maxBytes = nul
     unitCount: 0,
     payloadBytes,
     diff: null,
+    partial: false,
   };
   return {
     ok: true,
     diagnostics: [],
     fileCount: before.fileCount + after.fileCount,
-    unitCount: new Set([...before.ir.units, ...after.ir.units].map((unit) => unit.id)).size,
+    unitCount: new Set([...beforeSnapshot.byId.keys(), ...afterSnapshot.byId.keys()]).size,
     payloadBytes,
     diff,
     before,
     after,
+    partial: false,
   };
 }

package/cli/lib/authority/format.mjs

@@ -3,7 +3,7 @@ import path from "node:path";
 
 import { compareText, createLocator, makeDiagnostic, portablePath, REPAIRS, sortDiagnostics } from "./diagnostics.mjs";
 import { parseMarkdownAuthority, stringifyCanonicalMarkdown } from "./source-markdown.mjs";
-import { AUTHORITY_FORMAT_V2, loadAuthorityContract, parseYamlAuthority, stringifyCanonicalYaml } from "./source-yaml.mjs";
+import { loadAuthorityContract, parseYamlAuthority, stringifyCanonicalYaml } from "./source-yaml.mjs";
 import { validateFormatStructure } from "./validate.mjs";
 
 export class AuthorityInputError extends Error {
@@ -107,35 +107,7 @@ export async function parseAuthorityPath(inputPath, options = {}) {
   return { contract, files, documents, sources };
 }
 
-function uniformValue(values) {
-  return values.length > 0 && values.every((value) => value === values[0]) ? values[0] : null;
-}
-
-function upgradedYamlData(document, contract) {
-  const units = document.units.map((source) => structuredClone(source.data));
-  const identifier = new RegExp(contract.identifier_pattern);
-  const uniformOwner = uniformValue(units.map((unit) => unit.owner));
-  const activeRules = units.filter((unit) => unit.kind === "rule" && unit.lifecycle === "active");
-  const uniformScope = uniformValue(activeRules.map((unit) => (
-    Array.isArray(unit.scope) && unit.scope.length === 1 ? unit.scope[0] : null
-  )));
-  return {
-    format: AUTHORITY_FORMAT_V2,
-    ...((typeof uniformOwner === "string" && identifier.test(uniformOwner))
-      ? { owner: uniformOwner }
-      : document.data.format === AUTHORITY_FORMAT_V2 && Object.hasOwn(document.data, "owner") ? { owner: document.data.owner } : {}),
-    ...((typeof uniformScope === "string" && identifier.test(uniformScope))
-      ? { scope: uniformScope }
-      : document.data.format === AUTHORITY_FORMAT_V2 && Object.hasOwn(document.data, "scope") ? { scope: document.data.scope } : {}),
-    units,
-  };
-}
-
-export function canonicalText(document, options = {}) {
-  if (options.upgrade) {
-    if (document.profile !== "yaml") throw new AuthorityInputError("authority fmt --upgrade requires one YAML authority container");
-    return stringifyCanonicalYaml(upgradedYamlData(document, options.contract), { container: true });
-  }
+export function canonicalText(document) {
   return document.profile === "yaml"
     ? stringifyCanonicalYaml(document.data, { container: true })
     : stringifyCanonicalMarkdown(document.data);
@@ -178,7 +150,7 @@ export async function formatAuthorityFile(inputPath, options = {}) {
   const document = documents[0];
   const diagnostics = validateFormatStructure(document, contract);
   if (diagnostics.length > 0) return { ok: false, changed: false, diagnostics, fileCount: 1 };
-  const canonical = canonicalText(document, { upgrade: options.upgrade === true, contract });
+  const canonical = canonicalText(document);
   const changed = canonical !== document.sourceText;
   if (options.check && changed) return {
     ok: false,
@@ -187,7 +159,7 @@ export async function formatAuthorityFile(inputPath, options = {}) {
       code: "AUTH_FORMAT_DRIFT",
       file: document.file,
       range: document.locations.get("") ?? document.locator.range(0, document.sourceText.length),
-      reason: options.upgrade ? "authority source is not byte-canonical v2" : "authority source is not byte-canonical",
+      reason: "authority source is not byte-canonical",
       repair: REPAIRS.format,
     })],
     fileCount: 1,