@xhulz/nina 0.29.0 → 0.31.0

package/src/commands/pipeline.mjs

@@ -52,7 +52,7 @@ export function stageWords(text) {
  * - The line: from the first stage no forward edge reaches, the one forward edge each stage takes with no
  *   condition, until a stage has none.
  * - The gates: a stage off the line that a line stage sends work to on a condition, and that hands it on
- *   to the next stage of the line.
+ *   to a later stage of the line — the next one, or one past the stages it runs beside.
  * - The ends: where the line's last stage sends work on a condition, followed forward to a terminal.
  * - The loop-backs: every edge on a verdict that sends work back, to a stage or to the owner, grouped by
  *   the stage that sends it.
@@ -70,10 +70,14 @@ export function shapeOf(graph) {
     if (next.length !== 1) break;
     line.push(next[0].to);
   }
+  // A gate leaves the line on a condition and comes back to it further on: to the next stage, when it runs
+  // before that stage, or past it, when it runs beside the stages it skips — the way the database and
+  // integration gates run beside the reviewer, and `qa` waits for them all.
   const gates = [];
   line.forEach((stage, i) => {
     for (const e of forward.filter((e) => e.from === stage && e.when && !line.includes(e.to) && !TERMINALS.has(e.to))) {
-      if (i + 1 < line.length && forward.some((f) => f.from === e.to && f.to === line[i + 1])) gates.push({ from: stage, gate: e.to, to: line[i + 1], when: e.when });
+      const back = line.findIndex((s, j) => j > i && forward.some((f) => f.from === e.to && f.to === s));
+      if (back !== -1) gates.push({ from: stage, gate: e.to, to: line[back], beside: line.slice(i + 1, back), when: e.when });
     }
   });
   const last = line.at(-1);
@@ -248,7 +252,8 @@ export async function pipeline(argv) {
       const chain = (g) => `${g.from}${arrow}${g.gate}${arrow}${g.to}`;
       const col = Math.max(...shape.gates.map((g) => chain(g).length)) + 4;
       for (const g of shape.gates) {
-        console.log(`    ${name(g.from)}${arrow}${name(g.gate)}${arrow}${name(g.to)}${' '.repeat(col - chain(g).length)}${dim(fit(g.when, width - col - 6))}`);
+        const when = g.beside.length > 0 ? `beside the ${g.beside.join(', ')} · ${g.when}` : g.when;
+        console.log(`    ${name(g.from)}${arrow}${name(g.gate)}${arrow}${name(g.to)}${' '.repeat(col - chain(g).length)}${dim(fit(when, width - col - 6))}`);
       }
     }
   }

package/src/commands/upgrade.mjs

@@ -15,7 +15,8 @@ import { spawnSync } from 'node:child_process';
 import { HARNESS, legacyHint } from '../paths.mjs';
 import { existsSync, lstatSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
-import { composeProject, composedPaths, defaultedSlots, layerRootFor } from './compose.mjs';
+import { composeProject, composedPaths, defaultedSlots, layerRootFor, walk } from './compose.mjs';
+import { NEEDS, detected } from '../surfaces.mjs';
 import { filledSlots, projectSlots, referencedVocabulary } from './check.mjs';
 import { EXPECT_ENV } from '../expected.mjs';
 import { closeAnswered } from './learn.mjs';
@@ -213,6 +214,13 @@ export async function upgrade(argv, ctx) {
     .map((e) => e.name);
   const gone = surfaces.filter((s) => !available.includes(s));
   const kept = surfaces.filter((s) => available.includes(s));
+  // A surface the target release adds that this project's own files show it has. When a stack is split out
+  // of a concern — `prisma` out of `db` — its rules go with it, and a project that does not declare it loses
+  // them in silence: the rules that were in its specs yesterday are not there after the move.
+  const offeredBefore = (await readdir(join(from.dir, 'surfaces'), { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+  const offered = detected(await walk(target)).filter(
+    (d) => available.includes(d.surface) && !offeredBefore.includes(d.surface) && !surfaces.includes(d.surface) && (!NEEDS[d.surface] || kept.includes(NEEDS[d.surface])),
+  );
 
   const [vocabBefore, vocabAfter] = [
     await referencedVocabulary(from.dir, surfaces, target),
@@ -236,6 +244,11 @@ export async function upgrade(argv, ctx) {
 
   console.log(`  ${profile.core} → ${to}\n`);
 
+  if (offered.length > 0) {
+    console.log(`  ✗ ${offered.length} surface(s) ${to} adds that this project's files show it has — undeclared, their rules leave its specs:`);
+    for (const d of offered) console.log(`      ${d.surface} — ${d.why}`);
+    console.log(`      add each to "surfaces" in ${HARNESS}/profile.json, or pass --force to move without them.\n`);
+  }
   if (gone.length > 0) {
     console.log(`  ✗ ${gone.length} declared surface(s) do not exist in ${to}: ${gone.join(', ')}`);
     console.log(`      a rename cannot be guessed — pick the replacement yourself, and move the`);
@@ -309,7 +322,7 @@ export async function upgrade(argv, ctx) {
     console.log('');
   }
 
-  const blocking = gone.length + stranded.length + unwired.length + occupied.length + walledOff.length;
+  const blocking = gone.length + offered.length + stranded.length + unwired.length + occupied.length + walledOff.length;
   if (!apply) {
     console.log(
       blocking > 0

package/src/surfaces.mjs

@@ -0,0 +1,33 @@
+/**
+ * What the compiler knows about surfaces beyond their layers: which ones a repository's files reveal, and
+ * which ones only make sense on top of another.
+ *
+ * A surface is a question about what the project is — does it own persistent data, does it render a screen
+ * a person looks at — and its layer states what is true of every project that answers yes. A stack is a
+ * surface too, of another kind: `prisma` is how a project reaches the database it owns, and means nothing
+ * without one. The database surface used to be both at once, and a project that owned data but had not
+ * chosen its client was told its client was Prisma, its reads went through Accelerate and its tenant was
+ * `userId`.
+ *
+ * `init`, `check` and `upgrade` all read this, so a surface's evidence and its prerequisite are stated once.
+ */
+
+/** Surfaces a repository reveals by its files. The rest are claims about the domain. */
+export const DETECTABLE = [
+  { surface: 'db', why: 'a Prisma schema', test: (f) => f.some((p) => p.endsWith('schema.prisma')) },
+  { surface: 'prisma', why: 'a Prisma schema', test: (f) => f.some((p) => p.endsWith('schema.prisma')) },
+  { surface: 'edge-cf', why: 'a wrangler config', test: (f) => f.some((p) => /(^|\/)wrangler\.(toml|jsonc?)$/.test(p)) },
+  { surface: 'frontend', why: 'a Vite config', test: (f) => f.some((p) => /(^|\/)vite\.config\.[cm]?[jt]s$/.test(p)) },
+  { surface: 'blockchain', why: 'a Foundry or Hardhat config', test: (f) => f.some((p) => /(^|\/)(foundry\.toml|hardhat\.config\.[cm]?[jt]s)$/.test(p)) },
+];
+
+/** A stack surface, and the concern it is a stack of: declared without it, its rules have nowhere to land. */
+export const NEEDS = { prisma: 'db' };
+
+/**
+ * The surfaces a project's files reveal, with the evidence for each.
+ *
+ * @param {string[]} tree - The project's files, relative to it.
+ * @returns {{surface: string, why: string}[]}
+ */
+export const detected = (tree) => DETECTABLE.filter((d) => d.test(tree)).map(({ surface, why }) => ({ surface, why }));