@nimiplatform/nimi-coding 0.3.1 → 0.5.0

package/cli/lib/authority/compile.mjs

@@ -0,0 +1,92 @@
+import { compareText } from "./diagnostics.mjs";
+import { formattingDiagnostics, parseAuthorityPath } from "./format.mjs";
+import { validateAuthorityScopeBindings } from "./scope-bindings.mjs";
+import { buildSourceMap } from "./source-map.mjs";
+import { validateAuthoritySources } from "./validate.mjs";
+
+function lowerUnit(source) {
+  const data = source.data;
+  const unit = {
+    id: data.id,
+    kind: data.kind,
+    owner: data.owner,
+    lifecycle: data.lifecycle,
+    metadata: {
+      title: data.title,
+      ...(data.reason === undefined ? {} : { reason: data.reason }),
+    },
+    relations: [...data.relations]
+      .map((relation) => ({ type: relation.type, target: relation.target }))
+      .sort((left, right) => compareText(left.type, right.type) || compareText(left.target, right.target)),
+  };
+  if (data.lifecycle === "active" && data.kind === "definition") unit.semantic = { meaning: data.meaning };
+  if (data.lifecycle === "active" && data.kind === "rule") unit.semantic = {
+    modality: data.modality,
+    scope: [...data.scope].sort(compareText),
+    statement: data.statement,
+    condition: data.condition,
+    failure: data.failure,
+  };
+  return unit;
+}
+
+async function admittedSources(inputPath) {
+  const parsed = await parseAuthorityPath(inputPath);
+  const formatDiagnostics = formattingDiagnostics(parsed.documents, parsed.contract);
+  if (formatDiagnostics.length > 0) return { ok: false, diagnostics: formatDiagnostics, parsed };
+  const validation = validateAuthoritySources(parsed.sources, parsed.contract);
+  if (!validation.ok) return { ok: false, diagnostics: validation.diagnostics, parsed };
+  return { ok: true, diagnostics: [], parsed };
+}
+
+export async function checkAuthorityPath(inputPath, { scopeBindings = null } = {}) {
+  const result = await admittedSources(inputPath);
+  if (!result.ok || scopeBindings === null) return {
+    ok: result.ok,
+    diagnostics: result.diagnostics,
+    fileCount: result.parsed.files.length,
+    unitCount: result.ok ? result.parsed.sources.length : 0,
+  };
+  const scopeValidation = await validateAuthorityScopeBindings(result.parsed.sources, scopeBindings);
+  return {
+    ok: scopeValidation.ok,
+    diagnostics: scopeValidation.diagnostics,
+    fileCount: result.parsed.files.length,
+    unitCount: scopeValidation.ok ? result.parsed.sources.length : 0,
+  };
+}
+
+export async function compileAuthorityPath(inputPath) {
+  const admitted = await admittedSources(inputPath);
+  const inputBytes = admitted.parsed.documents.reduce((total, document) => total + document.inputBytes, 0);
+  if (!admitted.ok) return {
+    ok: false,
+    diagnostics: admitted.diagnostics,
+    fileCount: admitted.parsed.files.length,
+    unitCount: 0,
+    inputBytes,
+    ir: null,
+    sourceMap: null,
+  };
+  const sources = [...admitted.parsed.sources].sort((left, right) => compareText(left.data.id, right.data.id));
+  const ir = { units: sources.map(lowerUnit) };
+  const mapped = buildSourceMap(sources, ir);
+  if (!mapped.ok) return {
+    ok: false,
+    diagnostics: mapped.diagnostics,
+    fileCount: admitted.parsed.files.length,
+    unitCount: 0,
+    inputBytes,
+    ir: null,
+    sourceMap: null,
+  };
+  return {
+    ok: true,
+    diagnostics: [],
+    fileCount: admitted.parsed.files.length,
+    unitCount: ir.units.length,
+    inputBytes,
+    ir,
+    sourceMap: mapped.sourceMap,
+  };
+}

package/cli/lib/authority/compiled-snapshot.mjs

@@ -0,0 +1,143 @@
+import path from "node:path";
+
+import { compareText, portablePath } from "./diagnostics.mjs";
+
+class ReadonlyIndex {
+  #values;
+
+  constructor(entries) {
+    this.#values = new Map(entries);
+    Object.freeze(this);
+  }
+
+  get size() {
+    return this.#values.size;
+  }
+
+  get(key) {
+    return this.#values.get(key);
+  }
+
+  has(key) {
+    return this.#values.has(key);
+  }
+
+  *entries() {
+    for (const [key, value] of this.#values) yield Object.freeze([key, value]);
+  }
+
+  keys() {
+    return this.#values.keys();
+  }
+
+  values() {
+    return this.#values.values();
+  }
+
+  forEach(callback, thisArg = undefined) {
+    for (const [key, value] of this.#values) callback.call(thisArg, value, key, this);
+  }
+
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+
+  get [Symbol.toStringTag]() {
+    return "ReadonlyIndex";
+  }
+}
+
+function freezeTree(value, seen = new Set()) {
+  if (value === null || typeof value !== "object" || Object.isFrozen(value) || seen.has(value)) return value;
+  seen.add(value);
+  for (const key of Reflect.ownKeys(value)) freezeTree(value[key], seen);
+  return Object.freeze(value);
+}
+
+function readonlyIndex(entries) {
+  return new ReadonlyIndex([...entries].sort(([left], [right]) => compareText(left, right)));
+}
+
+function groupedIndex(entries, keys) {
+  const groups = new Map();
+  for (const entry of entries) {
+    for (const key of keys(entry)) {
+      const values = groups.get(key) ?? [];
+      values.push(entry);
+      groups.set(key, values);
+    }
+  }
+  return readonlyIndex([...groups.entries()].map(([key, values]) => [
+    key,
+    Object.freeze(values.sort((left, right) => compareText(left.unit.id, right.unit.id))),
+  ]));
+}
+
+function compareEdge(left, right) {
+  return compareText(left.source, right.source)
+    || compareText(left.type, right.type)
+    || compareText(left.target, right.target);
+}
+
+function adjacencyIndexes(entries) {
+  const outgoing = new Map(entries.map((entry) => [entry.unit.id, []]));
+  const incoming = new Map(entries.map((entry) => [entry.unit.id, []]));
+  for (const entry of entries) {
+    entry.unit.relations.forEach((relation, relationIndex) => {
+      const edge = Object.freeze({
+        source: entry.unit.id,
+        type: relation.type,
+        target: relation.target,
+        sourceUnitIndex: entry.unitIndex,
+        relationIndex,
+      });
+      outgoing.get(edge.source).push(edge);
+      incoming.get(edge.target).push(edge);
+    });
+  }
+  const finish = (index) => readonlyIndex([...index.entries()].map(([id, edges]) => [
+    id,
+    Object.freeze(edges.sort(compareEdge)),
+  ]));
+  return { outgoing: finish(outgoing), incoming: finish(incoming) };
+}
+
+export function createCompiledAuthoritySnapshot(compiled, inputRoot) {
+  if (
+    compiled?.ok !== true
+    || !Array.isArray(compiled?.ir?.units)
+    || compiled?.sourceMap?.fields === null
+    || typeof compiled?.sourceMap?.fields !== "object"
+  ) {
+    throw new TypeError("compiled authority snapshot requires one successful compiler result");
+  }
+  if (typeof inputRoot !== "string" || inputRoot.length === 0) {
+    throw new TypeError("compiled authority snapshot requires one non-empty input root");
+  }
+  const resolvedRoot = path.resolve(inputRoot);
+  const entries = compiled.ir.units.map((unit, unitIndex) => {
+    const mapped = compiled.sourceMap.fields[`/units/${unitIndex}/id`];
+    if (!mapped) throw new TypeError(`compiled authority snapshot cannot locate unit identity: ${unit.id}`);
+    return Object.freeze({
+      unit,
+      unitIndex,
+      container: portablePath(mapped.file, resolvedRoot),
+    });
+  });
+  const byId = readonlyIndex(entries.map((entry) => [entry.unit.id, entry]));
+  const byOwner = groupedIndex(entries, (entry) => [entry.unit.owner]);
+  const byScope = groupedIndex(entries, (entry) => entry.unit.semantic?.scope ?? []);
+  const byContainer = groupedIndex(entries, (entry) => [entry.container]);
+  const { incoming, outgoing } = adjacencyIndexes(entries);
+  freezeTree(compiled);
+  return Object.freeze({
+    inputRoot: resolvedRoot,
+    compiled,
+    byId,
+    byOwner,
+    byScope,
+    byContainer,
+    incoming,
+    outgoing,
+  });
+}