@xhulz/nina 0.79.0 → 0.81.0

package/src/commands/upgrade.mjs

@@ -23,7 +23,7 @@ import { tidyRetired } from './pills.mjs';
 import { lacksPackage, missingFragment, missingWiring, shippedScripts } from '../wiring.mjs';
 import { runSteps } from '../steps.mjs';
 import { granted } from '../tools.mjs';
-import { defaultVocabulary } from '../vocabulary.mjs';
+import { TOOK_OVER, defaultVocabulary, tierProblem, tiers } from '../vocabulary.mjs';
 
 /** What stops a move from outside it: Ctrl-C, a `kill`, the terminal closing. */
 const SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP'];
@@ -288,6 +288,14 @@ export async function upgrade(argv, ctx) {
     );
     return 1;
   }
+  // A tier the target release lacks would fail the compose that ends the move, after the pin had moved. Not
+  // forceable, and said before anything is read: the tier is set back first, or the move goes to a release that has it.
+  const tierError = tierProblem(onto.dir, profile.tier, to);
+  if (tierError) {
+    const way = Object.keys(tiers(onto.dir)).length > 0 ? `set one ${to} has with \`nina compose --tier\`, or take` : 'take';
+    console.error(`  ${tierError} — ${way} "tier" out of ${HARNESS}/profile.json before the move\n`);
+    return 1;
+  }
 
   const surfaces = profile.surfaces ?? [];
   const available = (await surfacesIn(onto.dir));
@@ -313,7 +321,7 @@ export async function upgrade(argv, ctx) {
 
   const declared = profile.vocabulary ?? {};
   // A name the new release supplies a default for is not owed: it composes as the default until declared.
-  const defaultsAfter = defaultVocabulary(onto.dir);
+  const defaultsAfter = defaultVocabulary(onto.dir, profile.tier);
   const waits = (key) => typeof profile.deferred?.[key] === 'string' && profile.deferred[key].trim() !== '';
   const needed = [...vocabAfter].filter((v) => ((!(v in declared) && !(v in defaultsAfter)) || declared[v] === null) && !waits(v)).sort();
   const unused = Object.keys(declared).filter((v) => !vocabAfter.has(v)).sort();
@@ -352,6 +360,13 @@ export async function upgrade(argv, ctx) {
   if (unused.length > 0) {
     console.log(`  · ${unused.length} vocabulary entr(ies) nothing in ${to} references: ${unused.join(', ')}\n`);
   }
+  // Stages that ran on a value this profile declares and, after the move, read a name of their own that it does not.
+  const tookOver = Object.entries(TOOK_OVER).filter(([name, was]) => vocabAfter.has(name) && !vocabBefore.has(name) && typeof declared[was] === 'string' && !(name in declared));
+  if (tookOver.length > 0) {
+    console.log(`  · ${tookOver.length} name(s) ${to} reads where it read one this profile declares — each composes as ${to}'s default until declared:`);
+    for (const [name, was] of tookOver) console.log(`      ${name}, was ${was}: ${defaultsAfter[name] ?? '(no default)'}, where ${was} is ${declared[was]}`);
+    console.log('');
+  }
   if (newSlots.length > 0) {
     console.log(`  · ${newSlots.length} new project slot(s) to fill:`);
     for (const s of newSlots.slice(0, 15)) console.log(`      ${s}`);

package/src/vocabulary.mjs

@@ -27,18 +27,92 @@ export const NAME = /^[A-Z][A-Z0-9_]*$/;
 /** A placeholder in a text, its name captured. */
 export const PLACEHOLDER = /\{\{([A-Z][A-Z0-9_]*)\}\}/g;
 
+/** A name a tier may move: a stage's model or its effort, never a command, a path or a limit. */
+const TIERED = /_(?:MODEL|EFFORT)$/;
+
+/**
+ * Names that took over stages from another, the new name → the one those stages read before. A project that
+ * declared the old name had them on its value; after the move they read the new one, at the release's default
+ * until it is declared too, and `upgrade` says so rather than move them in silence.
+ */
+export const TOOK_OVER = { ARCHITECT_MODEL: 'DEEP_MODEL', IMMUTABLE_MODEL: 'DEEP_MODEL', IMMUTABLE_EFFORT: 'DEEP_EFFORT' };
+
 /**
  * The defaults a layer root supplies, name → value. Anything that is not a string under an
  * upper-case name is ignored rather than trusted: a default reaches every project that pins it.
  *
+ * With a tier, that tier's models and efforts replace the release's own, so every reader of a
+ * default — compose, check, init, upgrade — reads the one the project composes. A tier the release
+ * does not have moves nothing here; {@link tierProblem} is what says so.
+ *
  * @param {string} layerRoot - A release directory, or the working tree.
+ * @param {string} [tier] - The profile's `tier`, when it declares one.
  * @returns {Record<string, string>}
  */
-export function defaultVocabulary(layerRoot) {
+export function defaultVocabulary(layerRoot, tier) {
+  let defaults = {};
   try {
     const parsed = JSON.parse(readFileSync(join(layerRoot, 'core', 'vocabulary.json'), 'utf8'));
-    return Object.fromEntries(Object.entries(parsed).filter(([name, value]) => NAME.test(name) && typeof value === 'string'));
+    defaults = Object.fromEntries(Object.entries(parsed).filter(([name, value]) => NAME.test(name) && typeof value === 'string'));
   } catch {
     return {};
   }
+  const levels = tiers(layerRoot);
+  return tier !== undefined && Object.hasOwn(levels, tier) ? { ...defaults, ...levels[tier] } : defaults;
+}
+
+/**
+ * The tiers a layer root supplies, level → the models and efforts it moves, from `core/tiers.json`.
+ *
+ * A tier is a named set of the defaults that decide what each stage runs on, so a project picks how
+ * much its pipeline spends in one word rather than five vocabulary values. Only a `_MODEL` or an
+ * `_EFFORT` name is taken: a tier that moved a command or a limit would change what a stage does, not
+ * what it runs on. A release from before tiers has none.
+ *
+ * @param {string} layerRoot - A release directory, or the working tree.
+ * @returns {Record<string, Record<string, string>>}
+ */
+export function tiers(layerRoot) {
+  try {
+    const parsed = JSON.parse(readFileSync(join(layerRoot, 'core', 'tiers.json'), 'utf8'));
+    return Object.fromEntries(
+      Object.entries(parsed)
+        .filter(([, moves]) => moves !== null && typeof moves === 'object' && !Array.isArray(moves))
+        .map(([level, moves]) => [level, Object.fromEntries(Object.entries(moves).filter(([name, value]) => NAME.test(name) && TIERED.test(name) && typeof value === 'string'))]),
+    );
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Why a tier cannot compose against a release, or null when it can — or when none is declared.
+ *
+ * @param {string} layerRoot - A release directory, or the working tree.
+ * @param {unknown} tier - The profile's `tier`, as written.
+ * @param {string} [release] - The release's name, for the message.
+ * @returns {string|null}
+ */
+export function tierProblem(layerRoot, tier, release = 'this release') {
+  if (tier === undefined) return null;
+  const levels = Object.keys(tiers(layerRoot));
+  if (levels.length === 0) return `tier "${tier}": ${release} has no tiers — they came in 0.81.0`;
+  if (typeof tier !== 'string' || !levels.includes(tier)) return `tier "${tier}" is not one ${release} has: ${levels.join(', ')}`;
+  return null;
+}
+
+/**
+ * What each kind of stage runs on, in one line, from the values a project composes with: the architect, the
+ * stages that judge (the reviewers, the design-reviewer, secops, devops), and the stages that carry a spec out.
+ * A release from before the architect had a model of its own gave it the judges'.
+ *
+ * @param {Record<string, string>} values - The project's vocabulary over its release's defaults.
+ * @returns {string}
+ */
+export function modelsLine(values) {
+  const at = (model, effort) => `${model ?? '?'} at ${effort ?? '?'}`;
+  return (
+    `architect ${at(values.ARCHITECT_MODEL ?? values.DEEP_MODEL, values.ARCHITECT_EFFORT)} · ` +
+    `reviewers ${at(values.DEEP_MODEL, values.DEEP_EFFORT)} · builders ${at(values.WORK_MODEL, values.WORK_EFFORT)}`
+  );
 }